windborne 1.2.8__py3-none-any.whl → 1.3.0__py3-none-any.whl

windborne/forecasts_api.py

@@ -6,18 +6,109 @@ from .utils import (
     print_table
 )
 
-from .api_request import make_api_request
+from .api_request import make_api_request, API_BASE_URL
 from .track_formatting import save_track
 
-FORECASTS_API_BASE_URL = "https://forecasts.windbornesystems.com/api/v1"
-FORECASTS_GRIDDED_URL = f"{FORECASTS_API_BASE_URL}/gridded"
-FORECASTS_HISTORICAL_URL = f"{FORECASTS_API_BASE_URL}/gridded/historical"
-FORECASTS_TCS_URL = f"{FORECASTS_API_BASE_URL}/tropical_cyclones"
+FORECASTS_API_BASE_URL = f"{API_BASE_URL}/forecasts/v1"
 TCS_SUPPORTED_FORMATS = ('.csv', '.json', '.geojson', '.gpx', '.kml', '.little_r')
 
 
+# Run information
+def get_run_information(initialization_time=None, ensemble_member=None, print_response=False, model='wm'):
+    """
+    Get run information for a given model initialization.
+
+    Args:
+        initialization_time (str, optional): Initialization time (ISO 8601). If omitted, latest is used.
+        ensemble_member (str|int, optional): Ensemble member (e.g., "mean" or member number as string/int)
+        print_response (bool, optional): Whether to print a formatted summary
+        model (str, optional): Forecast model (e.g., wm, wm4, wm4-intra, ecmwf-det)
+
+    Returns:
+        dict: API response containing initialization_time, forecast_zero, in_progress, and available list
+    """
+
+    params = {}
+    if initialization_time:
+        params['initialization_time'] = parse_time(initialization_time, init_time_flag=True)
+    if ensemble_member:
+        params['ens_member'] = ensemble_member
+
+    response = make_api_request(f"{FORECASTS_API_BASE_URL}/{model}/run_information", params=params)
+
+    if print_response and response is not None:
+        print("Initialization time:", response.get('initialization_time'))
+        print("Forecast zero:", response.get('forecast_zero'))
+        in_progress = response.get('in_progress')
+        if in_progress is not None:
+            print("In progress:", in_progress)
+
+        print("Available forecast hours:")
+        available = response.get('available', [])
+        for item in available:
+            hour = item.get('forecast_hour')
+            created_at = item.get('created_at')
+            archived = item.get('archived')
+
+            # eg:
+            # - 0 (created at 2025-10-29T00:00:00.000Z, archived)
+            # - 0 (created at 2025-10-29T00:00:00.000Z)
+            # - 0 (archived)
+
+            if created_at and archived:
+                print(f" - {hour} (created at {created_at}, archived)")
+            elif created_at and not archived:
+                print(f" - {hour} (created at {created_at})")
+            elif not created_at and archived:
+                print(f" - {hour} (archived)")
+            else:
+                print(f" - {hour} (archived)")
+
+    return response
+
+
+# Variables
+def get_variables(print_response=False, model='wm'):
+    """
+    Get available variables and levels for a given model.
+
+    Args:
+        print_response (bool, optional): Whether to print a formatted summary
+        model (str, optional): Forecast model (e.g., wm, wm4, wm4-intra, ecmwf-det)
+
+    Returns:
+        dict: API response containing sfc_variables, upper_variables, and levels
+    """
+
+    response = make_api_request(f"{FORECASTS_API_BASE_URL}/{model}/variables")
+
+    if print_response and response is not None:
+        sfc = response.get('sfc_variables', [])
+        upper = response.get('upper_variables', [])
+        levels = response.get('levels', [])
+
+        print("Surface variables:")
+        for v in sfc:
+            print(f" - {v}")
+
+        if len(upper) > 0:
+            print("Upper variables:")
+            for v in upper:
+                print(f" - {v}")
+        else:
+            print("No upper variables available")
+
+        if len(levels) > 0:
+            print("Levels:")
+            for lvl in levels:
+                print(f" - {lvl}")
+        else:
+            print("No levels available")
+
+    return response
+
 # Point forecasts
-def get_point_forecasts(coordinates, min_forecast_time=None, max_forecast_time=None, min_forecast_hour=None, max_forecast_hour=None, initialization_time=None, output_file=None, print_response=False):
+def get_point_forecasts(coordinates, min_forecast_time=None, max_forecast_time=None, min_forecast_hour=None, max_forecast_hour=None, initialization_time=None, output_file=None, print_response=False, model='wm'):
     """
     Get point forecasts from the API.
 
@@ -88,7 +179,7 @@ def get_point_forecasts(coordinates, min_forecast_time=None, max_forecast_time=N
     if print_response:
         print("Generating point forecast...")
 
-    response = make_api_request(f"{FORECASTS_API_BASE_URL}/points", params=params)
+    response = make_api_request(f"{FORECASTS_API_BASE_URL}/{model}/point_forecast", params=params)
 
     if output_file:
         save_arbitrary_response(output_file, response, csv_data_key='forecasts')
@@ -107,7 +198,7 @@ def get_point_forecasts(coordinates, min_forecast_time=None, max_forecast_time=N
     return response
 
 
-def get_gridded_forecast(variable, time=None, initialization_time=None, forecast_hour=None, output_file=None, silent=False, intracycle=False, ensemble_member=None):
+def get_gridded_forecast(variable, time=None, initialization_time=None, forecast_hour=None, output_file=None, silent=False, ensemble_member=None, model='wm'):
     """
     Get gridded forecast data from the API.
     Note that this is primarily meant to be used internally by the other functions in this module.
@@ -141,13 +232,19 @@ def get_gridded_forecast(variable, time=None, initialization_time=None, forecast
     elif time:
         params["time"] = parse_time(time)
 
-    if intracycle:
-        params["intracycle"] = intracycle
-
     if ensemble_member:
         params["ens_member"] = ensemble_member
 
-    response = make_api_request(f"{FORECASTS_GRIDDED_URL}/{variable}", params=params, as_json=False)
+    # Map variable strings like "500/temperature" to query params variable=temperature, level=500
+    request_params = dict(params)
+    if '/' in variable and variable.split('/')[0].isdigit():
+        level_str, var_name = variable.split('/', 1)
+        request_params['variable'] = var_name
+        request_params['level'] = int(level_str)
+    else:
+        request_params['variable'] = variable
+
+    response = make_api_request(f"{FORECASTS_API_BASE_URL}/{model}/gridded", params=request_params, as_json=False)
 
     if response is None:
         return None
@@ -159,56 +256,27 @@ def get_gridded_forecast(variable, time=None, initialization_time=None, forecast
 
     return response
 
-def get_full_gridded_forecast(time, output_file=None):
-    return get_gridded_forecast(variable="FULL", time=time, output_file=output_file)
-
-def get_temperature_2m(time, output_file=None):
-    return get_gridded_forecast(variable="temperature_2m", time=time, output_file=output_file)
-
-def get_dewpoint_2m(time, output_file=None):
-    return get_gridded_forecast(variable="dewpoint_2m", time=time, output_file=output_file)
-
-def get_wind_u_10m(time, output_file=None):
-    return get_gridded_forecast(variable="wind_u_10m", time=time, output_file=output_file)
-
-def get_wind_v_10m(time, output_file=None):
-    return get_gridded_forecast(variable="wind_v_10m", time=time, output_file=output_file)
-
-def get_500hpa_wind_u(time, output_file=None):
-    return get_gridded_forecast(variable="500/wind_u", time=time, output_file=output_file)
-
-def get_500hpa_wind_v(time, output_file=None):
-    return get_gridded_forecast(variable="500/wind_v", time=time, output_file=output_file)
-
-def get_500hpa_temperature(time, output_file=None):
-    return get_gridded_forecast(variable="500/temperature", time=time, output_file=output_file)
-
-def get_850hpa_temperature(time, output_file=None):
-    return get_gridded_forecast(variable="850/temperature", time=time, output_file=output_file)
-
-def get_pressure_msl(time, output_file=None):
-    return get_gridded_forecast(variable="pressure_msl", time=time, output_file=output_file)
-
-def get_500hpa_geopotential(time, output_file=None):
-    return get_gridded_forecast(variable="500/geopotential", time=time, output_file=output_file)
-
-def get_850hpa_geopotential(time, output_file=None):
-    return get_gridded_forecast(variable="850/geopotential", time=time, output_file=output_file)
-
-def get_historical_temperature_2m(initialization_time, forecast_hour, output_file=None):
-    return get_gridded_forecast(variable="temperature_2m", initialization_time=initialization_time, forecast_hour=forecast_hour, output_file=output_file)
-
-def get_historical_500hpa_geopotential(initialization_time, forecast_hour, output_file=None):
-    return get_gridded_forecast(variable="500/geopotential", initialization_time=initialization_time, forecast_hour=forecast_hour, output_file=output_file)
+def get_full_gridded_forecast(time=None, initialization_time=None, forecast_hour=None, output_file=None, silent=False, ensemble_member=None, model='wm'):
+    """
+    Get gridded forecast data for all variables from the API.
 
-def get_historical_500hpa_wind_u(initialization_time, forecast_hour, output_file=None):
-    return get_gridded_forecast(variable="500/wind_u", initialization_time=initialization_time, forecast_hour=forecast_hour, output_file=output_file)
+    Args:
+        time (str, optional): Date in either ISO 8601 format (YYYY-MM-DDTHH:00:00)
+                    or compact format (YYYYMMDDHH). May be used instead of initialization_time and forecast_hour.
+        initialization_time (str, optional): Date in either ISO 8601 format (YYYY-MM-DDTHH:00:00)
+                    or compact format (YYYYMMDDHH). May be used in conjunction with forecast_hour instead of time.
+        forecast_hour (int, optional): The forecast hour to get the forecast for. May be used in conjunction with initialization_time instead of time.
+        output_file (str, optional): Path to save the response data
+                                      Supported formats: .nc
+        silent (bool, optional): Whether to print output
+        ensemble_member (int, optional): The ensemble member to get the forecast for
+        model (str, optional): The model to get the forecast for
+    """
 
-def get_historical_500hpa_wind_v(initialization_time, forecast_hour, output_file=None):
-    return get_gridded_forecast(variable="500/wind_v", initialization_time=initialization_time, forecast_hour=forecast_hour, output_file=output_file)
+    return get_gridded_forecast(variable="all", time=time, initialization_time=initialization_time, forecast_hour=forecast_hour, output_file=output_file, silent=silent, ensemble_member=ensemble_member, model=model)
 
 
-def get_tropical_cyclones(initialization_time=None, basin=None, output_file=None, print_response=False):
+def get_tropical_cyclones(initialization_time=None, basin=None, output_file=None, print_response=False, model='wm'):
     """
     Get tropical cyclone data from the API.
 
@@ -246,7 +314,8 @@ def get_tropical_cyclones(initialization_time=None, basin=None, output_file=None
         params["basin"] = basin
 
     # Response here is a .json
-    response = make_api_request(FORECASTS_TCS_URL, params=params)
+    # Tropical cyclones endpoint is model-specific
+    response = make_api_request(f"{FORECASTS_API_BASE_URL}/{model}/tropical_cyclones", params=params)
 
     if output_file:
         if not output_file.lower().endswith(TCS_SUPPORTED_FORMATS):
@@ -262,13 +331,14 @@ def get_tropical_cyclones(initialization_time=None, basin=None, output_file=None
             # save_response_to_file() will throw error on saving {}
         elif response is None:
             print("-------------------------------------------------------")
-            print("You are too quick!\nThe tropical cyclone data for initialization time are not uploaded yet.")
-            print('You may check again in a few hour.')
+            print("Tropical cyclones have not yet been generated for this initialization time")
         else:
             save_track(output_file, response, require_ids=True)
 
     if print_response:
-        if len(response) == 0:
+        if not response:
+            print("No tropical cyclones for initialization time:", initialization_time)
+        elif len(response) == 0:
             print("No tropical cyclones for initialization time:", initialization_time)
         else:
             print("Tropical Cyclones for initialization time:", initialization_time)
@@ -279,18 +349,17 @@ def get_tropical_cyclones(initialization_time=None, basin=None, output_file=None
     return response
 
 
-def get_initialization_times(print_response=False, ensemble_member=None, intracycle=False):
+def get_initialization_times(print_response=False, ensemble_member=None, model='wm'):
     """
     Get available WeatherMesh initialization times (also known as cycle times).
 
-    Returns dict with keys "latest" and "available"
+    Returns dict with keys "latest", "available", and "in_progress"
     """
 
     params = {
         'ens_member': ensemble_member,
-        'intracycle': intracycle
     }
-    response = make_api_request(f"{FORECASTS_API_BASE_URL}/initialization_times.json", params=params)
+    response = make_api_request(f"{FORECASTS_API_BASE_URL}/{model}/initialization_times", params=params)
 
     if print_response:
         print("Latest initialization time:", response['latest'])
@@ -298,70 +367,30 @@ def get_initialization_times(print_response=False, ensemble_member=None, intracy
         for time in response['available']:
             print(f" - {time}")
 
-    return response
-
-
-def get_historical_initialization_times(print_response=False, ensemble_member=None, intracycle=False):
-    """
-    Get historical initialization times for forecasts from our archive
-    These may be higher latency to fetch and cannot be used for custom point forecasting
-    """
-    params = {
-        'ens_member': ensemble_member,
-        'intracycle': intracycle
-    }
-    response = make_api_request(f"{FORECASTS_API_BASE_URL}/historical_initialization_times.json", params=params)
-
-    if print_response:
-        print("Available historical initialization times:")
-        for time in response:
+        print("In progress initialization times:")
+        for time in response['in_progress']:
             print(f" - {time}")
 
-
-def get_forecast_hours(print_response=False, ensemble_member=None, intracycle=False):
-    """
-    Get available forecast hours for WeatherMesh
-    This may include initialization times that are not included in the initialization times API that represent outputs
-    that are still being generated.
-
-    Returns dict with keys of initialization times and values of available forecast hours
-    """
-
-    params = {
-        'ens_member': ensemble_member,
-        'intracycle': intracycle
-    }
-    response = make_api_request(f"{FORECASTS_API_BASE_URL}/forecast_hours.json", params=params)
-
-    if print_response:
-        print("Available forecast hours:")
-        for time, hours in response.items():
-            print(f" - {time}: {', '.join([str(hour) for hour in hours])}")
-
     return response
 
 
-def get_generation_times(print_response=False, ensemble_member=None, intracycle=False):
+def get_archived_initialization_times(print_response=False, ensemble_member=None, model='wm', page_end=None):
     """
-    Get the creation time for each forecast hour output file.
-
-    Returns dict with keys of initialization times and values of dicts, each of which has keys of forecast hours and values of creation times (as ISO strings)
+    Get archived initialization times for forecasts from our archive.
+    These may be higher latency to fetch and cannot be used for custom point forecasting.
     """
-
     params = {
         'ens_member': ensemble_member,
-        'intracycle': intracycle
     }
-    response = make_api_request(f"{FORECASTS_API_BASE_URL}/generation_times.json", params=params)
+    if page_end:
+        params['page_end'] = parse_time(page_end)
+    response = make_api_request(f"{FORECASTS_API_BASE_URL}/{model}/initialization_times/archive", params=params)
 
     if print_response:
-        print("Generation times:")
-        for time, hours in response.items():
-            print(f" - {time}:")
-            for hour, creation_time in hours.items():
-                print(f"   - {hour}: {creation_time}")
-
-    return response
+        print("Available archived initialization times:")
+        times = response.get('archived_initialization_times', response)
+        for time in times:
+            print(f" - {time}")
 
 
 # Tropical cyclones
@@ -407,78 +436,241 @@ def download_and_save_output(output_file, response, silent=False):
             print(f"Error processing the file: {e}")
         return False
 
-def get_population_weighted_hdd(initialization_time, intracycle=False, ens_member=None, external_model=None, output_file=None, print_response=False):
+def get_population_weighted_hdd(initialization_time, ens_member=None, output_file=None, print_response=False, model='wm'):
     """
     Get population weighted HDD data from the API.
     """
     params = {
         "initialization_time": initialization_time,
-        "intracycle": intracycle,
         "ens_member": ens_member,
-        "external_model": external_model
     }
-    response = make_api_request(f"{FORECASTS_API_BASE_URL}/hdd", params=params, as_json=True)
+    response = make_api_request(f"{API_BASE_URL}/insights/v1/{model}/hdds", params=params, as_json=True)
     
     if output_file:
         if output_file.endswith('.csv'):
             import csv
 
-            # save as csv, with a row for each region, and a column for each date, sorted alphabetically by region
-            regions = sorted(response['hdd'].keys())
             dates = response['dates']
-            data = [[response['hdd'][region][dates[i]] for region in regions] for i in range(len(dates))]  
-
-            with open(output_file, 'w') as f:
-                writer = csv.writer(f)
-                writer.writerow(['Region'] + dates)
-
-                for region in regions:
-                    writer.writerow([region] + [response['hdd'][region][date] for date in dates])
+            hdd_map = response.get('hdd', {})
+
+            keys = list(hdd_map.keys())
+            is_date_keyed = False
+            if len(keys) > 0 and isinstance(keys[0], str):
+                import re
+                is_date_keyed = re.match(r"^\d{4}-\d{2}-\d{2}", keys[0]) is not None
+
+            if is_date_keyed:
+                region_set = set()
+                for date in dates:
+                    if isinstance(hdd_map.get(date), dict):
+                        region_set.update(hdd_map[date].keys())
+                regions = sorted(region_set)
+                with open(output_file, 'w') as f:
+                    writer = csv.writer(f)
+                    writer.writerow(['Region'] + dates)
+                    for region in regions:
+                        row = [region]
+                        for date in dates:
+                            value = ''
+                            if isinstance(hdd_map.get(date), dict):
+                                value = hdd_map[date].get(region, '')
+                            row.append(value)
+                        writer.writerow(row)
+            else:
+                regions = sorted(hdd_map.keys())
+                with open(output_file, 'w') as f:
+                    writer = csv.writer(f)
+                    writer.writerow(['Region'] + dates)
+                    for region in regions:
+                        writer.writerow([region] + [hdd_map.get(region, {}).get(date, '') for date in dates])
     
     if print_response:
         dates = response['dates']
-        print(response['hdd']['Alabama'])
-        for region in sorted(response['hdd'].keys()):
-            print(f"{region}:")
-            for i in range(len(dates)):
-                print(f"  {dates[i]}: {response['hdd'][region][dates[i]]}")
+        hdd_map = response.get('hdd', {})
+        keys = list(hdd_map.keys())
+        is_date_keyed = False
+        if len(keys) > 0 and isinstance(keys[0], str):
+            import re
+            is_date_keyed = re.match(r"^\d{4}-\d{2}-\d{2}", keys[0]) is not None
+
+        if is_date_keyed:
+            region_set = set()
+            for date in dates:
+                if isinstance(hdd_map.get(date), dict):
+                    region_set.update(hdd_map[date].keys())
+            for region in sorted(region_set):
+                print(f"{region}:")
+                for date in dates:
+                    if isinstance(hdd_map.get(date), dict) and region in hdd_map[date]:
+                        print(f"  {date}: {hdd_map[date][region]}")
+        else:
+            for region in sorted(hdd_map.keys()):
+                print(f"{region}:")
+                for date in dates:
+                    if isinstance(hdd_map.get(region), dict) and date in hdd_map[region]:
+                        print(f"  {date}: {hdd_map[region][date]}")
     
     return response
 
-def get_population_weighted_cdd(initialization_time, intracycle=False, ens_member=None, external_model=None, output_file=None, print_response=False):
+def get_population_weighted_cdd(initialization_time, ens_member=None, output_file=None, print_response=False, model='wm'):
     """
     Get population weighted CDD data from the API.
     """
     params = {
         "initialization_time": initialization_time,
-        "intracycle": intracycle,
         "ens_member": ens_member,
-        "external_model": external_model
     }
-    response = make_api_request(f"{FORECASTS_API_BASE_URL}/cdd", params=params, as_json=True)
+    response = make_api_request(f"{API_BASE_URL}/insights/v1/{model}/cdds", params=params, as_json=True)
     
     if output_file:
         if output_file.endswith('.csv'):
             import csv
 
-            # save as csv, with a row for each region, and a column for each date, sorted alphabetically by region
-            regions = sorted(response['cdd'].keys())
             dates = response['dates']
-            data = [[response['cdd'][region][dates[i]] for region in regions] for i in range(len(dates))]  
-
-            with open(output_file, 'w') as f:
-                writer = csv.writer(f)
-                writer.writerow(['Region'] + dates)
-
-                for region in regions:
-                    writer.writerow([region] + [response['cdd'][region][date] for date in dates])
+            cdd_map = response.get('cdd', {})
+
+            keys = list(cdd_map.keys())
+            is_date_keyed = False
+            if len(keys) > 0 and isinstance(keys[0], str):
+                import re
+                is_date_keyed = re.match(r"^\d{4}-\d{2}-\d{2}", keys[0]) is not None
+
+            if is_date_keyed:
+                region_set = set()
+                for date in dates:
+                    if isinstance(cdd_map.get(date), dict):
+                        region_set.update(cdd_map[date].keys())
+                regions = sorted(region_set)
+                with open(output_file, 'w') as f:
+                    writer = csv.writer(f)
+                    writer.writerow(['Region'] + dates)
+                    for region in regions:
+                        row = [region]
+                        for date in dates:
+                            value = ''
+                            if isinstance(cdd_map.get(date), dict):
+                                value = cdd_map[date].get(region, '')
+                            row.append(value)
+                        writer.writerow(row)
+            else:
+                regions = sorted(cdd_map.keys())
+                with open(output_file, 'w') as f:
+                    writer = csv.writer(f)
+                    writer.writerow(['Region'] + dates)
+                    for region in regions:
+                        writer.writerow([region] + [cdd_map.get(region, {}).get(date, '') for date in dates])
     
     if print_response:
         dates = response['dates']
-        print(response['cdd']['Alabama'])
-        for region in sorted(response['cdd'].keys()):
-            print(f"{region}:")
-            for i in range(len(dates)):
-                print(f"  {dates[i]}: {response['cdd'][region][dates[i]]}")
+        cdd_map = response.get('cdd', {})
+        keys = list(cdd_map.keys())
+        is_date_keyed = False
+        if len(keys) > 0 and isinstance(keys[0], str):
+            import re
+            is_date_keyed = re.match(r"^\d{4}-\d{2}-\d{2}", keys[0]) is not None
+
+        if is_date_keyed:
+            region_set = set()
+            for date in dates:
+                if isinstance(cdd_map.get(date), dict):
+                    region_set.update(cdd_map[date].keys())
+            for region in sorted(region_set):
+                print(f"{region}:")
+                for date in dates:
+                    if isinstance(cdd_map.get(date), dict) and region in cdd_map[date]:
+                        print(f"  {date}: {cdd_map[date][region]}")
+        else:
+            for region in sorted(cdd_map.keys()):
+                print(f"{region}:")
+                for date in dates:
+                    if isinstance(cdd_map.get(region), dict) and date in cdd_map[region]:
+                        print(f"  {date}: {cdd_map[region][date]}")
     
     return response
+
+
+def get_point_forecasts_interpolated(coordinates, min_forecast_time=None, max_forecast_time=None, min_forecast_hour=None, max_forecast_hour=None, initialization_time=None, ensemble_member=None, output_file=None, print_response=False, model='wm'):
+    """
+    Get interpolated point forecasts from the API.
+
+    Args:
+        coordinates (str | list): "lat,lon;lat,lon" string or list of tuples/strings/dicts
+        min_forecast_time (str, optional): Minimum forecast time (ISO 8601 formats supported)
+        max_forecast_time (str, optional): Maximum forecast time (ISO 8601 formats supported)
+        min_forecast_hour (int, optional): Minimum forecast hour
+        max_forecast_hour (int, optional): Maximum forecast hour
+        initialization_time (str, optional): Initialization time (ISO 8601). If omitted, latest is used
+        ensemble_member (str | int, optional): Ensemble member (e.g., "mean" or 0-23)
+        output_file (str, optional): Save response to .json or .csv (csv_data_key='forecasts')
+        print_response (bool, optional): Print response summary to stdout
+        model (str, optional): Forecast model (e.g., wm, wm4, wm4-intra, ecmwf-det)
+    """
+
+    formatted_coordinates = coordinates
+
+    if isinstance(coordinates, list):
+        coordinate_items = []
+        for coordinate in coordinates:
+            if isinstance(coordinate, (tuple, list)):
+                if len(coordinate) != 2:
+                    print("Coordinates should be tuples or lists with two elements: latitude and longitude.")
+                    return
+                coordinate_items.append(f"{coordinate[0]},{coordinate[1]}")
+            elif isinstance(coordinate, str):
+                coordinate_items.append(coordinate)
+            elif isinstance(coordinate, dict):
+                if 'latitude' in coordinate and 'longitude' in coordinate:
+                    coordinate_items.append(f"{coordinate['latitude']},{coordinate['longitude']}")
+                elif 'lat' in coordinate and 'lon' in coordinate:
+                    coordinate_items.append(f"{coordinate['lat']},{coordinate['lon']}")
+                elif 'lat' in coordinate and 'long' in coordinate:
+                    coordinate_items.append(f"{coordinate['lat']},{coordinate['long']}")
+                elif 'lat' in coordinate and 'lng' in coordinate:
+                    coordinate_items.append(f"{coordinate['lat']},{coordinate['lng']}")
+                else:
+                    print("Coordinates should be dictionaries with keys 'latitude' and 'longitude'.")
+                    return
+        formatted_coordinates = ";".join(coordinate_items)
+
+    formatted_coordinates = formatted_coordinates.replace(" ", "")
+    if not formatted_coordinates:
+        print("To get interpolated points forecasts you must provide coordinates.")
+        return
+
+    params = {"coordinates": formatted_coordinates}
+
+    if min_forecast_time:
+        params["min_forecast_time"] = parse_time(min_forecast_time)
+    if max_forecast_time:
+        params["max_forecast_time"] = parse_time(max_forecast_time)
+    if min_forecast_hour:
+        params["min_forecast_hour"] = int(min_forecast_hour)
+    if max_forecast_hour:
+        params["max_forecast_hour"] = int(max_forecast_hour)
+    if initialization_time:
+        params["initialization_time"] = parse_time(initialization_time, init_time_flag=True)
+    if ensemble_member is not None:
+        params["ens_member"] = ensemble_member
+
+    if print_response:
+        print("Generating interpolated point forecast...")
+
+    # Note: interpolated endpoint uses underscore path: point_forecast/interpolated
+    response = make_api_request(f"{FORECASTS_API_BASE_URL}/{model}/point_forecast/interpolated", params=params)
+
+    if output_file:
+        save_arbitrary_response(output_file, response, csv_data_key='forecasts')
+
+    if print_response and response is not None:
+        unformatted_coordinates = formatted_coordinates.split(';')
+        # Include latitude/longitude along with standard surface variables
+        keys = ['time', 'temperature_2m', 'dewpoint_2m', 'wind_u_10m', 'wind_v_10m', 'precipitation', 'pressure_msl', 'latitude', 'longitude']
+        headers = ['Time', '2m Temperature (°C)', '2m Dewpoint (°C)', 'Wind U (m/s)', 'Wind V (m/s)', 'Precipitation (mm)', 'MSL Pressure (hPa)', 'Latitude', 'Longitude']
+
+        forecasts = response.get('forecasts', [])
+        for i in range(min(len(forecasts), len(unformatted_coordinates))):
+            latitude, longitude = unformatted_coordinates[i].split(',')
+            print(f"\nForecast for ({latitude}, {longitude})")
+            print_table(forecasts[i], keys=keys, headers=headers)
+
+    return response

{windborne-1.2.8.dist-info → windborne-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: windborne
-Version: 1.2.8
+Version: 1.3.0
 Summary: A Python library for interacting with WindBorne Data and Forecasts API
 Author-email: WindBorne Systems <data@windbornesystems.com>
 Classifier: Programming Language :: Python :: 3

windborne-1.3.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+windborne/__init__.py,sha256=UQLEVUvRS4Es8unszEVVBS_744be3GSNPcomeDvu_3c,1709
+windborne/api_request.py,sha256=phPCgm40JwAn1bf6osMOH40Sw_OxmlH_gx-W7KxYmtg,7949
+windborne/cli.py,sha256=ToYo_DxhYEjeYET6RtAaZbdgEJnMkbwVI1ynwtOrYj4,30484
+windborne/data_api.py,sha256=saIS5NsoNWEwsyL6uREP-SvwHyf-ngZLTbRJoWmEGMw,34582
+windborne/forecasts_api.py,sha256=Zp4wtUQI0F4pIbAHirhfJzTpBthCFraUKH8S8FpNkaE,29568
+windborne/observation_formatting.py,sha256=c739aaun6aaYhXl5VI-SRGR-TDS355_0Bfu1t6McoiM,14993
+windborne/track_formatting.py,sha256=LaLfTyjpWoOtHmReJPLViY0MKm_iPL_5I2OB_lNvGGA,10054
+windborne/utils.py,sha256=H8gvZ4Lrr0UmLl25iMZs6NsZliCY_73Ved_rBIqxJg4,7240
+windborne-1.3.0.dist-info/METADATA,sha256=ZZ3ddTk7ZY-qnJxspEKAQm2v9Ub6ISrWZHyLg_-KagM,1304
+windborne-1.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+windborne-1.3.0.dist-info/entry_points.txt,sha256=j_YrqdCDrCd7p5MIwQ2BYwNXEi95VNANzLRJmcXEg1U,49
+windborne-1.3.0.dist-info/top_level.txt,sha256=PE9Lauriu5S5REf7JKhXprufZ_V5RiZ_TnfnrLGJrmE,10
+windborne-1.3.0.dist-info/RECORD,,