windborne 1.1.1__py3-none-any.whl → 1.1.3__py3-none-any.whl

windborne/__init__.py

@@ -14,6 +14,7 @@ from .data_api import (
     get_flying_missions,
     get_mission_launch_site,
     get_predicted_path,
+    get_flight_path
 )
 
 # Import Forecasts API functions
@@ -50,6 +51,7 @@ __all__ = [
     "get_flying_missions",
     "get_mission_launch_site",
     "get_predicted_path",
+    "get_flight_path",
 
     "get_point_forecasts",
     "get_initialization_times",

windborne/api_request.py

@@ -199,8 +199,7 @@ def make_api_request(url, params=None, as_json=True, retry_counter=0):
                     mission_id = url.split('/missions/')[1].split('/')[0]
                     print(f"Mission ID provided: {mission_id}")
                     print(f"No mission found with id: {mission_id}")
-                    return None
-
+            return None
         elif http_err.response.status_code == 502:
             print(f"Temporary connection failure; sleeping for {2**retry_counter}s before retrying")
             print(f"Underlying error: 502 Bad Gateway")

windborne/cli.py

@@ -14,6 +14,7 @@ from . import (
     get_flying_missions,
     get_mission_launch_site,
     get_predicted_path,
+    get_flight_path,
 
     get_point_forecasts,
     get_initialization_times,
@@ -125,6 +126,11 @@ def main():
     prediction_parser.add_argument('mission_id', help='Mission ID')
     prediction_parser.add_argument('output', nargs='?', help='Output file')
 
+    # Get Flight Path Command
+    flight_path_parser = subparsers.add_parser('flight-path', help='Get traveled flight path')
+    flight_path_parser.add_argument('mission_id', help='Mission ID')
+    flight_path_parser.add_argument('output', nargs='?', help='Output file')
+
     ####################################################################################################################
     # FORECASTS API FUNCTIONS
     ####################################################################################################################
@@ -139,7 +145,7 @@ def main():
     points_parser.add_argument('-mh','--min-hour', type=int, help='Minimum forecast hour')
     points_parser.add_argument('-xh','--max-hour', type=int, help='Maximum forecast hour')
     points_parser.add_argument('-i', '--init-time', help='Initialization time')
-    points_parser.add_argument('output_file', help='Output file')
+    points_parser.add_argument('output_file', nargs='?', help='Output file')
 
     # GRIDDED FORECASTS
     ####################################################################################################################
@@ -210,9 +216,9 @@ def main():
     ####################################################################################################################
 
     # Tropical Cyclones Command
-    cyclones_parser = subparsers.add_parser('cyclones', help='Get tropical cyclone forecasts')
-    cyclones_parser.add_argument('-b', '--basin',  help='Optional: filter tropical cyclones on basin[ NA, EP, WP, NI, SI, AU, SP]')
-    cyclones_parser.add_argument('args', nargs='*',
+    tropical_cyclones_parser = subparsers.add_parser('tropical_cyclones', help='Get tropical cyclone forecasts')
+    tropical_cyclones_parser.add_argument('-b', '--basin',  help='Optional: filter tropical cyclones on basin[ NA, EP, WP, NI, SI, AU, SP]')
+    tropical_cyclones_parser.add_argument('args', nargs='*',
                                  help='[optional: initialization time (YYYYMMDDHH, YYYY-MM-DDTHH, or YYYY-MM-DDTHH:mm:ss)] output_file')
 
     # Initialization Times Command
@@ -377,8 +383,18 @@ def main():
     elif args.command == 'predict-path':
         get_predicted_path(
             mission_id=args.mission_id,
-            output_file=args.output
+            output_file=args.output,
+            print_result=(not args.output)
         )
+
+    elif args.command == 'flight-path':
+        get_flight_path(
+            mission_id=args.mission_id,
+            output_file=args.output,
+            print_result=(not args.output)
+        )
+
+
     ####################################################################################################################
     # FORECASTS API FUNCTIONS CALLED
     ####################################################################################################################
@@ -396,15 +412,12 @@ def main():
             min_forecast_hour=min_forecast_hour,
             max_forecast_hour=max_forecast_hour,
             initialization_time=initialization_time,
-            output_file=args.output_file
+            output_file=args.output_file,
+            print_response=(not args.output_file)
         )
 
     elif args.command == 'init_times':
-        if get_initialization_times():
-            print("Available initialization times for point forecasts:\n")
-            pprint(get_initialization_times())
-        else:
-            print("We can't currently display available initialization times for point forecasts:\n")
+        get_initialization_times(print_response=True)
 
     elif args.command == 'grid_temp_2m':
         # Parse grid_temp_2m arguments
@@ -589,39 +602,28 @@ def main():
             print("Too many arguments")
             print("\nUsage: windborne hist_500hpa_wind_v initialization_time forecast_hour output_file")
 
-    elif args.command == 'cyclones':
+    elif args.command == 'tropical_cyclones':
         # Parse cyclones arguments
-        basin_name = 'ALL basins'
+        basin_name = 'all basins'
         if args.basin:
             basin_name = f"{args.basin} basin"
-            print(f"Checking for tropical cyclones only within {args.basin} basin\n")
 
         if len(args.args) == 0:
-            print("Loading tropical cyclones for our latest available initialization time\n")
-            if get_tropical_cyclones(basin=args.basin):
-                print(f"Found {len(get_tropical_cyclones())} cyclone(s)\n")
-                pprint(get_tropical_cyclones(basin=args.basin))
-                return
-            else:
-                print("There are no active tropical cyclones for our latest available initialization time.")
+            get_tropical_cyclones(basin=args.basin, print_response=True)
+            return
         elif len(args.args) == 1:
             if '.' in args.args[0]:
                 # Save tcs with the latest available initialization time in filename
                 get_tropical_cyclones(basin=args.basin, output_file=args.args[0])
             else:
                 # Display tcs for selected initialization time
-                if get_tropical_cyclones(initialization_time=args.args[0], basin=args.basin):
-                    print(f"Loading tropical cyclones for initialization time {args.args[0]}\n")
-                    print(f"Found {len(get_tropical_cyclones(initialization_time=args.args[0]))} cyclone(s)\n")
-                    pprint(get_tropical_cyclones(initialization_time=args.args[0], basin=args.basin))
-                else:
-                    print(f"No active tropical cyclones for {basin_name} and {args.args[0]} initialization time.")
+                get_tropical_cyclones(initialization_time=args.args[0], basin=args.basin, print_response=True)
         elif len(args.args) == 2:
             print(f"Saving tropical cyclones for initialization time {args.args[0]} and {basin_name}\n")
             get_tropical_cyclones(initialization_time=args.args[0], basin=args.basin, output_file=args.args[1])
         else:
             print("Error: Too many arguments")
-            print("Usage: windborne cyclones [initialization_time] output_file")
+            print("Usage: windborne tropical_cyclones [initialization_time] output_file")
 
     else:
         parser.print_help()

windborne/data_api.py

@@ -6,7 +6,8 @@ import json
 
 from .api_request import make_api_request
 from .observation_formatting import format_little_r, convert_to_netcdf
-from .utils import to_unix_timestamp, save_arbitrary_response
+from .utils import to_unix_timestamp, save_arbitrary_response, print_table
+from .track_formatting import save_track
 
 DATA_API_BASE_URL = "https://sensor-data.windbornesystems.com/api/v1"
 
@@ -551,6 +552,9 @@ def get_flying_missions(output_file=None, print_results=False):
     url = f"{DATA_API_BASE_URL}/missions.json"
     flying_missions_response = make_api_request(url)
     flying_missions = flying_missions_response.get("missions", [])
+    for mission in flying_missions:
+        if mission.get('number'):
+            mission['name'] = f"W-{mission['number']}"
 
     # Display currently flying missions only if we are in cli and we don't save info in file
     if print_results:
@@ -617,7 +621,8 @@ def get_mission_launch_site(mission_id=None, output_file=None, print_result=Fals
 
     return response.get('launch_site')
 
-def get_predicted_path(mission_id=None, output_file=None):
+
+def get_predicted_path(mission_id=None, output_file=None, print_result=False):
     """
         Fetches the predicted flight path for a given mission.
         Displays currently flying missions if the provided mission ID is invalid.
@@ -625,7 +630,7 @@ def get_predicted_path(mission_id=None, output_file=None):
         Args:
             mission_id (str): The ID of the mission to fetch the prediction for.
             output_file (str): Optional path to save the response data.
-                               If provided, saves the data in CSV format.
+            print_result (bool): Whether to print the results in the CLI.
 
         Returns:
             list: The API response containing the predicted flight path data.
@@ -635,40 +640,70 @@ def get_predicted_path(mission_id=None, output_file=None):
         return
 
     # Check if provided mission ID belong to a flying mission
-    flying_missions_response = get_flying_missions()
-    flying_missions = flying_missions_response.get("missions", [])
+    flying_missions = get_flying_missions()
+
+    mission = None
+    for candidate in flying_missions:
+        if candidate.get('id') == mission_id or candidate.get('name') == mission_id:
+            mission = candidate
+            break
 
-    if mission_id not in [mission.get("id") for mission in flying_missions]:
+    if mission is None:
         print(f"Provided mission ID '{mission_id}' does not belong to a mission that is currently flying.")
 
         # Display currently flying missions
         if flying_missions:
             print("\nCurrently flying missions:\n")
 
-            # Define headers and data
-            headers = ["Index", "Mission ID", "Mission Name"]
-            rows = [
-                [str(i), mission.get("id", "N/A"), mission.get("name", "Unnamed Mission")]
-                for i, mission in enumerate(flying_missions, start=1)
-            ]
-
-            # Kinda overkill | but it's a good practice if we ever change missions naming convention
-            # Calculate column widths
-            col_widths = [max(len(cell) for cell in col) + 2 for col in zip(headers, *rows)]
-
-            # Display table
-            print("".join(f"{headers[i]:<{col_widths[i]}}" for i in range(len(headers))))
-            print("".join("-" * col_width for col_width in col_widths))
-            for row in rows:
-                print("".join(f"{row[i]:<{col_widths[i]}}" for i in range(len(row))))
+            print_table(flying_missions, keys=['id', 'name'], headers=['Mission ID', 'Mission Name'])
         else:
             print("No missions are currently flying.")
         return
 
-    url = f"{DATA_API_BASE_URL}/missions/{mission_id}/prediction.json"
+    url = f"{DATA_API_BASE_URL}/missions/{mission.get('id')}/prediction.json"
     response = make_api_request(url)
 
+    if response is None:
+        return
+
     if output_file:
-        save_arbitrary_response(output_file, response, csv_data_key='prediction')
-    
-    return response.get('prediction')
+        name = mission.get('name', mission_id)
+        save_track(output_file, {name: response['prediction']}, time_key='time')
+
+    if print_result:
+        print("Predicted flight path\n")
+        print_table(response['prediction'], keys=['time', 'latitude', 'longitude', 'altitude'], headers=['Time', 'Latitude', 'Longitude', 'Altitude'])
+
+    return response.get('prediction')
+
+
+def get_flight_path(mission_id=None, output_file=None, print_result=False):
+    """
+        Fetches the flight path for a given mission.
+
+        Args:
+            mission_id (str): The ID of the mission to fetch the flight path for.
+            output_file (str): Optional path to save the response data.
+            print_result (bool): Whether to print the results in the CLI.
+
+        Returns:
+            list: The API response containing the flight path.
+    """
+    if not mission_id:
+        print("A mission id is required to get a flight path")
+        return
+
+    url = f"{DATA_API_BASE_URL}/missions/{mission_id}/flight_data.json"
+    response = make_api_request(url)
+
+    if response is None:
+        return
+
+    if output_file:
+        save_track(output_file, {mission_id: response['flight_data']}, time_key='transmit_time')
+
+    if print_result:
+        print("Flight path\n")
+        print_table(response['flight_data'], keys=['transmit_time', 'latitude', 'longitude', 'altitude'], headers=['Time', 'Latitude', 'Longitude', 'Altitude'])
+
+    return response.get('flight_data')

windborne/forecasts_api.py

@@ -2,29 +2,22 @@ import requests
 
 from .utils import (
     parse_time,
-    save_arbitrary_response
+    save_arbitrary_response,
+    print_table
 )
 
-from .api_request import (
-    make_api_request
-)
-
-from .cyclone_formatting import (
-    save_track_as_geojson,
-    save_track_as_gpx,
-    save_track_as_kml,
-    save_track_as_little_r
-)
+from .api_request import make_api_request
+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"
-TCS_SUPPORTED_FORMATS = ('.csv', '.json', '.geojson', '.gpx', '.kml', 'little_r')
+TCS_SUPPORTED_FORMATS = ('.csv', '.json', '.geojson', '.gpx', '.kml', '.little_r')
 
 
 # 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):
+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):
     """
     Get point forecasts from the API.
 
@@ -38,6 +31,7 @@ def get_point_forecasts(coordinates, min_forecast_time=None, max_forecast_time=N
         initialization_time (str, optional): Initialization time in ISO 8601 format (YYYY-MM-DDTHH:00:00)
         output_file (str, optional): Path to save the response data
                                       Supported formats: .json, .csv
+        print_response (bool, optional): Whether to print the response data
     """
 
     # coordinates should be formatted as a semi-colon separated list of latitude,longitude tuples, eg 37,-121;40.3,-100
@@ -91,13 +85,25 @@ def get_point_forecasts(coordinates, min_forecast_time=None, max_forecast_time=N
         initialization_time = parse_time(initialization_time,init_time_flag=True)
         params["initialization_time"] = initialization_time
 
-    print("Generating point forecast...")
+    if print_response:
+        print("Generating point forecast...")
 
     response = make_api_request(f"{FORECASTS_API_BASE_URL}/points", params=params)
 
     if output_file:
         save_arbitrary_response(output_file, response, csv_data_key='forecasts')
 
+    if print_response:
+        unformatted_coordinates = formatted_coordinates.split(';')
+
+        keys = ['time', 'temperature_2m', 'dewpoint_2m', 'wind_u_10m', 'wind_v_10m', 'precipitation', 'pressure_msl']
+        headers = ['Time', '2m Temperature (°C)', '2m Dewpoint (°C)', 'Wind U (m/s)', 'Wind V (m/s)', 'Precipitation (mm)', 'MSL Pressure (hPa)']
+
+        for i in range(len(response['forecasts'])):
+            latitude, longitude = unformatted_coordinates[i].split(',')
+            print(f"\nForecast for ({latitude}, {longitude})")
+            print_table(response['forecasts'][i], keys=keys, headers=headers)
+
     return response
 
 
@@ -126,6 +132,9 @@ def get_gridded_forecast(time, variable, output_file=None):
 
     response = make_api_request(f"{FORECASTS_GRIDDED_URL}/{variable}", params=params, as_json=False)
 
+    if response is None:
+        return None
+
     if output_file:
         print(f"Output URL found; downloading to {output_file}...")
         download_and_save_output(output_file, response)
@@ -181,6 +190,9 @@ def get_historical_output(initialization_time, forecast_hour, variable, output_f
 
     response = make_api_request(f"{FORECASTS_HISTORICAL_URL}/{variable}", params=params, as_json=False)
 
+    if response is None:
+        return None
+
     if output_file:
         print(f"Output URL found; downloading to {output_file}...")
         download_and_save_output(output_file, response)
@@ -201,7 +213,7 @@ def get_historical_500hpa_wind_v(initialization_time, forecast_hour, output_file
     return get_historical_output(initialization_time, forecast_hour, "500/wind_v", output_file)
 
 
-def get_tropical_cyclones(initialization_time=None, basin=None, output_file=None):
+def get_tropical_cyclones(initialization_time=None, basin=None, output_file=None, print_response=False):
     """
     Get tropical cyclone data from the API.
 
@@ -209,8 +221,10 @@ def get_tropical_cyclones(initialization_time=None, basin=None, output_file=None
         initialization_time (str): Date in either ISO 8601 format (YYYY-MM-DDTHH:00:00)
                                  or compact format (YYYYMMDDHH)
                                  where HH must be 00, 06, 12, or 18
+        basin (str, optional): Basin code (e.g., 'NA', 'EP', 'WP', 'NI', 'SI', 'AU', 'SP')
         output_file (str, optional): Path to save the response data
                                       Supported formats: .json, .csv, .gpx, .geojson, .kml, .little_r
+        print_response (bool, optional): Whether to print the response data
 
     Returns:
         dict: API response data or None if there's an error
@@ -221,7 +235,6 @@ def get_tropical_cyclones(initialization_time=None, basin=None, output_file=None
         initialization_time_parsed = parse_time(initialization_time, init_time_flag=True)
         params["initialization_time"] = initialization_time_parsed
     else:
-        # Madee this for our displaying message when no active tcs found
         initialization_time = 'latest'
 
     if basin:
@@ -241,11 +254,7 @@ def get_tropical_cyclones(initialization_time=None, basin=None, output_file=None
     response = make_api_request(FORECASTS_TCS_URL, params=params)
 
     if output_file:
-        if '.' not in output_file:
-            print("You have to provide a filetype for your output file.")
-            print_tc_supported_formats()
-            exit (4)
-        elif not output_file.lower().endswith(TCS_SUPPORTED_FORMATS):
+        if not output_file.lower().endswith(TCS_SUPPORTED_FORMATS):
             print("Unsupported file format.")
             print_tc_supported_formats()
             exit(44)
@@ -254,42 +263,28 @@ def get_tropical_cyclones(initialization_time=None, basin=None, output_file=None
             # make_api_request covers 403, 404, 502, HTTP, Connections Errors
             # If we pass all of these and we get an empty dictionary ==> there are no active TCs
             print("There are no active tropical cyclones for your request\n")
-            print("We didn't save any file on your machine.")
             # It's pointless to save an empty file
             # 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 hours again.')
-        elif output_file.lower().endswith('.csv'):
-            # Flatten for CSV
-            flattened_data = []
+            print('You may check again in a few hour.')
+        else:
+            save_track(output_file, response, require_ids=True)
+
+    if print_response:
+        if len(response) == 0:
+            print("No tropical cyclones for initialization time:", initialization_time)
+        else:
+            print("Tropical Cyclones for initialization time:", initialization_time)
             for cyclone_id, tracks in response.items():
-                for track in tracks:
-                    track_data = {
-                        'cyclone_id': cyclone_id,
-                        'latitude': track['latitude'],
-                        'longitude': track['longitude'],
-                        'time': track['time']
-                    }
-                    flattened_data.append(track_data)
-            save_arbitrary_response(output_file, {'prediction': flattened_data}, csv_data_key='prediction')
-        elif output_file.lower().endswith('.json'):
-            # Direct save for JSON
-            save_arbitrary_response(output_file, response)
-        elif output_file.lower().endswith('.geojson'):
-            save_track_as_geojson(output_file, response)
-        elif output_file.lower().endswith('.gpx'):
-            save_track_as_gpx(output_file, response)
-        elif output_file.lower().endswith('.kml'):
-            save_track_as_kml(output_file, response)
-        elif output_file.lower().endswith('.little_r'):
-            save_track_as_little_r(output_file, response)
+                print(f"\nCyclone ID: {cyclone_id}")
+                print_table(tracks, keys=['time', 'latitude', 'longitude'], headers=['Time', 'Latitude', 'Longitude'])
 
     return response
 
 
-def get_initialization_times():
+def get_initialization_times(print_response=False):
     """
     Get available WeatherMesh initialization times (also known as cycle times).
 
@@ -298,6 +293,12 @@ def get_initialization_times():
 
     response = make_api_request(f"{FORECASTS_API_BASE_URL}/initialization_times.json")
 
+    if print_response:
+        print("Latest initialization time:", response['latest'])
+        print("Available initialization times:")
+        for time in response['available']:
+            print(f" - {time}")
+
     return response
 
 

windborne/{cyclone_formatting.py → track_formatting.py}

@@ -1,15 +1,69 @@
-from datetime import datetime, timezone
+from datetime import datetime
+import json
 
+TRACK_SUPPORTED_FORMATS = ['.csv', '.json', '.geojson', '.gpx', '.kml', 'little_r']
 
-def save_track_as_little_r(filename, cyclone_data):
+def save_track(output_file, track_data, time_key='time', require_ids=False):
     """
-    Convert and save cyclone data in little_R format.
+    Save track data to a file in the specified format.
+    Expects track_data to be a dictionary with cyclone/mission IDs as keys and lists of track points as values.
     """
+    include_id = require_ids or len(track_data) > 1
+
+    if output_file.lower().endswith('.json'):
+        with open(output_file, 'w', encoding='utf-8') as f:
+            json.dump(track_data, f, indent=4)
+    elif output_file.lower().endswith('.csv'):
+        save_track_as_csv(output_file, track_data, time_key=time_key, include_id=include_id)
+    elif output_file.lower().endswith('.geojson'):
+        save_track_as_geojson(output_file, track_data, time_key=time_key)
+    elif output_file.lower().endswith('.gpx'):
+        save_track_as_gpx(output_file, track_data, time_key=time_key)
+    elif output_file.lower().endswith('.kml'):
+        save_track_as_kml(output_file, track_data)
+    elif output_file.lower().endswith('.little_r'):
+        save_track_as_little_r(output_file, track_data, time_key=time_key)
+    else:
+        print(f"Unsupported file format. Supported formats are: {', '.join(TRACK_SUPPORTED_FORMATS)}")
+        return
+
+
+def save_track_as_csv(filename, track_data, time_key='time', include_id=False):
+    """
+    Convert and save track data as CSV.
+    """
+    flattened_data = []
+    for name, tracks in track_data.items():
+        for track in tracks:
+            track_data = {
+                'id': name,
+                'latitude': track['latitude'],
+                'longitude': track['longitude'],
+                'time': track[time_key]
+            }
+            flattened_data.append(track_data)
+
     with open(filename, 'w', encoding='utf-8') as f:
-        for cyclone_id, tracks in cyclone_data.items():
+        if include_id:
+            f.write('id,latitude,longitude,time\n')
+        else:
+            f.write('latitude,longitude,time\n')
+
+        for row in flattened_data:
+            if include_id:
+                f.write(f"{row['id']},{row['latitude']},{row['longitude']},{row['time']}\n")
+            else:
+                f.write(f"{row['latitude']},{row['longitude']},{row['time']}\n")
+
+def save_track_as_little_r(filename, track_data, time_key='time'):
+    """
+    Convert and save track data in little_R format.
+    """
+    with open(filename, 'w', encoding='utf-8') as f:
+        for cyclone_id, tracks in track_data.items():
             for track in tracks:
                 # Parse the time
-                dt = datetime.fromisoformat(track['time'].replace('Z', '+00:00'))
+                dt = datetime.fromisoformat(track[time_key].replace('Z', '+00:00'))
 
                 # Header line 1
                 header1 = f"{float(track['latitude']):20.5f}{float(track['longitude']):20.5f}{'HMS':40}"
@@ -35,21 +89,20 @@ def save_track_as_little_r(filename, cyclone_data):
     print("Saved to", filename)
 
 
-def save_track_as_kml(filename, cyclone_data):
+def save_track_as_kml(filename, track_data):
     """
-    Convert and save cyclone data as KML, handling meridian crossing.
+    Convert and save track data as KML, handling meridian crossing.
     """
     kml = '<?xml version="1.0" encoding="UTF-8"?>\n'
     kml += '<kml xmlns="http://www.opengis.net/kml/2.2">\n<Document>\n'
 
-    for cyclone_id, tracks in cyclone_data.items():
-        kml += f'  <Placemark>\n    <name>{cyclone_id}</name>\n    <MultiGeometry>\n'
+    for id, tracks in track_data.items():
+        kml += f'  <Placemark>\n    <name>{id}</name>\n    <MultiGeometry>\n'
 
         current_segment = []
 
         for i in range(len(tracks)):
             lon = float(tracks[i]['longitude'])
-            lat = float(tracks[i]['latitude'])
 
             if not current_segment:
                 current_segment.append(tracks[i])
@@ -61,7 +114,7 @@ def save_track_as_kml(filename, cyclone_data):
             if abs(lon - prev_lon) > 180:
                 # Write the current segment
                 kml += '      <LineString>\n        <coordinates>\n'
-                coordinates = [f'          {track["longitude"]},{track["latitude"]},{0}'
+                coordinates = [f'          {track["longitude"]},{track["latitude"]},{track.get("altitude", 0)}'
                                for track in current_segment]
                 kml += '\n'.join(coordinates)
                 kml += '\n        </coordinates>\n      </LineString>\n'
@@ -74,7 +127,7 @@ def save_track_as_kml(filename, cyclone_data):
         # Write the last segment if it's not empty
         if current_segment:
             kml += '      <LineString>\n        <coordinates>\n'
-            coordinates = [f'          {track["longitude"]},{track["latitude"]},{0}'
+            coordinates = [f'          {track["longitude"]},{track["latitude"]},{track.get("altitude", 0)}'
                            for track in current_segment]
             kml += '\n'.join(coordinates)
             kml += '\n        </coordinates>\n      </LineString>\n'
@@ -88,12 +141,12 @@ def save_track_as_kml(filename, cyclone_data):
     print(f"Saved to {filename}")
 
 
-def save_track_as_gpx(filename, cyclone_data):
-    """Convert and save cyclone data as GPX, handling meridian crossing."""
+def save_track_as_gpx(filename, track_data, time_key='time'):
+    """Convert and save track data as GPX, handling meridian crossing."""
     gpx = '<?xml version="1.0" encoding="UTF-8"?>\n'
     gpx += '<gpx version="1.1" creator="Windborne" xmlns="http://www.topografix.com/GPX/1/1">\n'
 
-    for cyclone_id, tracks in cyclone_data.items():
+    for cyclone_id, tracks in track_data.items():
         gpx += f'  <trk>\n    <name>{cyclone_id}</name>\n'
 
         current_segment = []
@@ -101,7 +154,6 @@ def save_track_as_gpx(filename, cyclone_data):
 
         for i in range(len(tracks)):
             lon = float(tracks[i]['longitude'])
-            lat = float(tracks[i]['latitude'])
 
             if not current_segment:
                 current_segment.append(tracks[i])
@@ -130,7 +182,7 @@ def save_track_as_gpx(filename, cyclone_data):
             gpx += '    <trkseg>\n'
             for point in current_segment:
                 gpx += f'      <trkpt lat="{point["latitude"]}" lon="{point["longitude"]}">\n'
-                gpx += f'        <time>{point["time"]}</time>\n'
+                gpx += f'        <time>{point[time_key]}</time>\n'
                 gpx += '      </trkpt>\n'
             gpx += '    </trkseg>\n'
 
@@ -143,10 +195,10 @@ def save_track_as_gpx(filename, cyclone_data):
     print(f"Saved to {filename}")
 
 
-def save_track_as_geojson(filename, cyclone_data):
-    """Convert and save cyclone data as GeoJSON, handling meridian crossing."""
+def save_track_as_geojson(filename, track_data, time_key='time'):
+    """Convert and save track data as GeoJSON, handling meridian crossing."""
     features = []
-    for cyclone_id, tracks in cyclone_data.items():
+    for id, tracks in track_data.items():
         # Initialize lists to store line segments
         line_segments = []
         current_segment = []
@@ -188,9 +240,9 @@ def save_track_as_geojson(filename, cyclone_data):
         feature = {
             "type": "Feature",
             "properties": {
-                "cyclone_id": cyclone_id,
-                "start_time": tracks[0]['time'],
-                "end_time": tracks[-1]['time']
+                "id": id,
+                "start_time": tracks[0][time_key],
+                "end_time": tracks[-1][time_key]
             },
             "geometry": {
                 "type": "MultiLineString",

windborne/utils.py

@@ -46,7 +46,7 @@ def to_unix_timestamp(date_string):
 
 # Supported date format
 # Compact format YYYYMMDDHH
-def parse_time(time, init_time_flag=None):
+def parse_time(time, init_time_flag=None, require_past=False):
     """
     Parse and validate initialization time with support for multiple formats.
     Returns validated initialization time in ISO format, or None if invalid.
@@ -78,10 +78,9 @@ def parse_time(time, init_time_flag=None):
                 print("  - Initialization time hour must be 00, 06, 12, or 18")
                 exit(2)
 
-        if parsed_date > datetime.now():
-            print(f"How would it be to live in {parsed_date} ?\n")
-            print("Looks like you are coming from the future!\n")
-            exit(1111)
+        if require_past and parsed_date > datetime.now():
+            print(f"Invalid date: {time} -- cannot be in the future")
+            exit(2)
 
         return parsed_date.strftime('%Y-%m-%dT%H:00:00')
 
@@ -158,3 +157,33 @@ def save_arbitrary_response(output_file, response, csv_data_key=None):
     else:
         print("Unsupported file format. Please use either .json or .csv.")
         exit(4)
+
+
+def print_table(data, keys=None, headers=None):
+    if len(data) == 0:
+        print("No data found")
+        return
+
+    if keys is None:
+        keys = list(data[0].keys())
+
+    if headers is None:
+        headers = keys
+
+    # headers = ["Index", "Mission ID", "Mission Name"]
+    rows = [
+        [
+            str(value.get(key)) if key != 'i' else str(i)
+            for key in keys
+        ]
+        for i, value in enumerate(data, start=1)
+    ]
+
+    # Calculate column widths
+    col_widths = [max(len(cell) for cell in col) + 2 for col in zip(headers, *rows)]
+
+    # Display table
+    print("".join(f"{headers[i]:<{col_widths[i]}}" for i in range(len(headers))))
+    print("".join("-" * col_width for col_width in col_widths))
+    for row in rows:
+        print("".join(f"{row[i]:<{col_widths[i]}}" for i in range(len(row))))

{windborne-1.1.1.dist-info → windborne-1.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: windborne
-Version: 1.1.1
+Version: 1.1.3
 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.1.3.dist-info/RECORD

@@ -0,0 +1,13 @@
+windborne/__init__.py,sha256=DcxmiLq4UnjoRjZd4UeuYt29FBsi9paMXGtI91Itn04,1826
+windborne/api_request.py,sha256=zh1TaaZAaRfAXp2NYMja75fKeduWLfao02JRRFVpQCA,11108
+windborne/cli.py,sha256=xRPRLh50iC4Uu0AYEHL-LHRxUnpxqB_Mn-easp5VSK4,35370
+windborne/data_api.py,sha256=QsG1NJyOCzTrTLRaoz5Z4nGRI0HCMEJvbDyRUlY3Usg,31388
+windborne/forecasts_api.py,sha256=E0X9FyUW2yz3pQZKkFBYDMeg6PhFJ1bp4z1Cg1g0uGs,13987
+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.1.3.dist-info/METADATA,sha256=unPmA3uPzt8obgqSmJSrsSzSLat4yH7o3uJtb-i3wy0,1235
+windborne-1.1.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+windborne-1.1.3.dist-info/entry_points.txt,sha256=j_YrqdCDrCd7p5MIwQ2BYwNXEi95VNANzLRJmcXEg1U,49
+windborne-1.1.3.dist-info/top_level.txt,sha256=PE9Lauriu5S5REf7JKhXprufZ_V5RiZ_TnfnrLGJrmE,10
+windborne-1.1.3.dist-info/RECORD,,

windborne-1.1.1.dist-info/RECORD

@@ -1,13 +0,0 @@
-windborne/__init__.py,sha256=0bPtPzBG3djZMVfyUNhapiEqCSyN8SSDsm_eCZ4kwhc,1783
-windborne/api_request.py,sha256=J7kcCC3xiISHnrTLxMkFQCEu8rg8UntYvFfP5wkLabQ,11117
-windborne/cli.py,sha256=hAnG1n6ZDICqj3nvjS8Xkc3psLeL-Hxewkmy-FABSCU,35807
-windborne/cyclone_formatting.py,sha256=0S8S_PflRGm6ftUlyR2aGGyX6IRn0hbUTEWptu7f8Q8,7886
-windborne/data_api.py,sha256=JBdedKWdx3eXKz0wGKqDLkR-QYl8O2SjutPL3LPx4l8,30457
-windborne/forecasts_api.py,sha256=-IM78Dr10rV-CKVqRWXpptJPe7Hh64DNMO3P3zVgvuQ,13790
-windborne/observation_formatting.py,sha256=c739aaun6aaYhXl5VI-SRGR-TDS355_0Bfu1t6McoiM,14993
-windborne/utils.py,sha256=AJhvdwtfDrV0NQyN_I5JxXr6K3UgFlPCwUGqApe-c2E,6431
-windborne-1.1.1.dist-info/METADATA,sha256=W5ZRFOnDBarbmqo8Wr4Ix8NWC47VqpsYaQYLVo3W5Vk,1235
-windborne-1.1.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-windborne-1.1.1.dist-info/entry_points.txt,sha256=j_YrqdCDrCd7p5MIwQ2BYwNXEi95VNANzLRJmcXEg1U,49
-windborne-1.1.1.dist-info/top_level.txt,sha256=PE9Lauriu5S5REf7JKhXprufZ_V5RiZ_TnfnrLGJrmE,10
-windborne-1.1.1.dist-info/RECORD,,