tide and sea temp data

Author: ryansurf

src/api.py

@@ -4,7 +4,7 @@
 
 import logging
 from concurrent.futures import ThreadPoolExecutor
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from functools import lru_cache
 from http import HTTPStatus
 from threading import Lock
@@ -14,6 +14,7 @@
 import requests
 from cachetools import TTLCache, cached
 from geopy.geocoders import Nominatim
+from geopy.distance import great_circle
 
 from src import helper
 from src.open_meteo import openmeteo_client
@@ -32,9 +33,11 @@
 _rain_cache = TTLCache(maxsize=_MAXSIZE, ttl=_TTL)
 forecast_cache = TTLCache(maxsize=_MAXSIZE, ttl=_TTL)
 _hourlyforecast_cache = TTLCache(maxsize=_MAXSIZE, ttl=_TTL)
+_tide_cache = TTLCache(maxsize=_MAXSIZE, ttl=_TTL)
 _ocean_lock = Lock()
 
 
+
 @lru_cache(maxsize=128)
 def get_coordinates(args: tuple) -> list | str:
     """
@@ -183,7 +186,7 @@ def ocean_information(
     params = {
         "latitude": lat,
         "longitude": long,
-        "current": ["wave_height", "wave_direction", "wave_period"],
+        "current": ["wave_height", "wave_direction", "wave_period", "sea_surface_temperature"],
         "length_unit": unit,
         "timezone": "auto",
         "forecast_days": 3,
@@ -202,8 +205,9 @@ def ocean_information(
     current_wave_height = round(current.Variables(0).Value(), decimal)
     current_wave_direction = round(current.Variables(1).Value(), decimal)
     current_wave_period = round(current.Variables(2).Value(), decimal)
+    current_sea_surface_temperature = current.Variables(3).Value()
 
-    return [current_wave_height, current_wave_direction, current_wave_period]
+    return [current_wave_height, current_wave_direction, current_wave_period, current_sea_surface_temperature]
 
 
 @cached(ocean_history_cache, lock=_ocean_lock)
@@ -482,6 +486,69 @@ def get_hourly_forecast(
 
     return curr_hour_data
 
+@cached(_tide_cache, lock=_ocean_lock)
+def get_tide_data(lat: float, long: float):
+    """
+    Fetches tide data for the given cords
+    """
+    station_id, station_distance = nearest_station(lat, long)
+    begin = (datetime.now(timezone.utc) - timedelta(days=1)).strftime("%Y%m%d")
+
+
+    url = "https://api.tidesandcurrents.noaa.gov/api/prod/datagetter"
+    params = {
+        "station": station_id,
+        "product": "predictions",
+        "datum": "MLLW",
+        "interval": "hilo",        # high/low only; omit for 6-min intervals
+        "units": "english",      
+        "time_zone": "gmt",
+        "format": "json",
+        "begin_date": begin,
+        "range": 72,   # hours
+    }
+    r = requests.get(url, params=params, timeout=10)
+    r.raise_for_status()
+    return r.json()
+
+
+@lru_cache(maxsize=1)
+def _get_stations():
+    url = "https://api.tidesandcurrents.noaa.gov/mdapi/prod/webapi/stations.json"
+    r = requests.get(url, params={"type": "tidepredictions"}, timeout=10)
+    r.raise_for_status()
+    return r.json()["stations"]
+
+def nearest_station(lat: float, long: float) -> tuple[str, float]:
+    """
+    returns the id of the nearest NOAA station in respect to the given cords
+    """
+    min_station_distance = float("inf")
+    nearest_id = None
+    surf_spot_cords = (float(lat), float(long))
+
+    stations = _get_stations()
+
+    for station in stations:
+        station_cords = (float(station["lat"]), float(station["lng"]))
+        station_id = station["id"]
+        distance = great_circle(surf_spot_cords, station_cords).mi
+        if distance < min_station_distance:
+            min_station_distance = distance
+            nearest_id = station_id
+
+    if nearest_id is None:
+        raise RuntimeError("No stations returned")
+
+    return nearest_id, min_station_distance
+
+
+def _safe_current_tide(lat: float, long: float):
+    try:
+        return helper.current_tide(lat, long)
+    except Exception:
+        return None
+
 
 def gather_data(lat: float | str, long: float | str, arguments: dict) -> dict:
     """
@@ -492,7 +559,7 @@ def gather_data(lat: float | str, long: float | str, arguments: dict) -> dict:
     lat, long = float(lat), float(long)
     dec, unit = arguments["decimal"], arguments["unit"]
 
-    with ThreadPoolExecutor(max_workers=8) as executor:
+    with ThreadPoolExecutor(max_workers=9) as executor:
         futures = {
             "ocean": executor.submit(ocean_information, lat, long, dec, unit),
             "uv": executor.submit(get_uv, lat, long, dec, unit),
@@ -504,6 +571,7 @@ def gather_data(lat: float | str, long: float | str, arguments: dict) -> dict:
                 ocean_information_history, lat, long, dec, unit
             ),
             "uv_hist": executor.submit(get_uv_history, lat, long, dec, unit),
+            "tide": executor.submit(_safe_current_tide, lat, long),
         }
         results = {k: f.result() for k, f in futures.items()}
 
@@ -514,6 +582,12 @@ def gather_data(lat: float | str, long: float | str, arguments: dict) -> dict:
     rain_sum, precipitation_probability_max = results["rain"]
     json_forecast = helper.forecast_to_json(results["forecast"], dec)
 
+    sea_temp_c = results["ocean"][3]
+    if unit == "imperial":
+        sea_temp = round(sea_temp_c * 9 / 5 + 32, dec)
+    else:
+        sea_temp = round(sea_temp_c, dec)
+
     return {
         "Lat": lat,
         "Long": long,
@@ -535,6 +609,8 @@ def gather_data(lat: float | str, long: float | str, arguments: dict) -> dict:
         "Precipitation Probability Max": precipitation_probability_max,
         "Cloud Cover": results["hourly"]["cloud_cover"],
         "Visibility": results["hourly"]["visibility"],
+        "Tide": results["tide"],
+        "Sea Surface Temperature": sea_temp,
     }
 
 
@@ -556,3 +632,7 @@ def separate_args_and_get_location(args: list) -> dict:
 
 # Backward-compatible alias for the misspelled name
 seperate_args_and_get_location = separate_args_and_get_location
+
+
+if __name__ == "__main__":
+    print(get_tide_data(40.741895, -73.989308))

src/helper.py

@@ -4,13 +4,18 @@
 
 import json
 import logging
+import sys
+from datetime import datetime, timezone
+from math import cos, pi
 
 from src import api, art
 from src.gpt import get_llm_client
 
+
 logger = logging.getLogger(__name__)
 
 MAX_FORECAST_DAYS = 7
+EARTH_RADIUS_MILES = 3956
 
 DEFAULT_ARGUMENTS = {
     "show_wave": True,
@@ -35,6 +40,8 @@
     "gpt": False,
     "show_cloud_cover": False,
     "show_visibility": False,
+    "show_tide": True,
+    "show_sea_temp": True,
 }
 
 
@@ -113,6 +120,8 @@ def set_output_values(args, args_dict):  # noqa
         "scc": ("show_cloud_cover", True),
         "show_visibility": ("show_visibility", True),
         "sv": ("show_visibility", True),
+        "hide_tide": ("show_tide", False),
+        "ht": ("show_tide", False),
     }
 
     for arg in args:
@@ -232,12 +241,25 @@ def print_ocean_data(arguments_dict, ocean_data_dict):
         ),
         ("show_cloud_cover", "Cloud Cover", "Cloud Cover: "),
         ("show_visibility", "Visibility", "Visibility: "),
+        ("show_sea_temp", "Sea Surface Temperature", "Sea Surface Temp: "),
     ]
 
     for arg_key, data_key, label in mappings:
         if arguments_dict[arg_key]:
             print(f"{label}{ocean_data_dict[data_key]}")
 
+    if arguments_dict.get("show_tide") and ocean_data_dict.get("Tide"):
+        tide = ocean_data_dict["Tide"]
+        incoming = tide["direction"] == "incoming"
+        arrow = "↑" if incoming else "↓"
+        if sys.stdout.isatty():
+            color = art.colors["green"] if incoming else art.colors["red"]
+            arrow = f"{color}{arrow}{art.colors['end']}"
+        extreme = tide["next_extreme"]
+        extreme_type = "High" if extreme["type"] == "H" else "Low"
+        extreme_time = datetime.fromisoformat(extreme["time"]).strftime("%H:%M UTC")
+        print(f"Tide: {tide['height_ft']} ft {arrow} | Next {extreme_type}: {extreme['height']:.2f} ft @ {extreme_time}")
+
 
 def print_forecast(ocean, forecast):
     """
@@ -382,14 +404,77 @@ def get_gpt_response(surf_data):
     """
     Builds a surf summary and returns the GPT response.
     """
+    unit_label = "°F" if surf_data.get("Unit") == "imperial" else "°C"
+
+    tide_desc = ""
+    if surf_data.get("Tide"):
+        tide = surf_data["Tide"]
+        extreme = tide["next_extreme"]
+        extreme_type = "high" if extreme["type"] == "H" else "low"
+        extreme_time = datetime.fromisoformat(extreme["time"]).strftime("%H:%M UTC")
+        tide_desc = (
+            f" The tide is currently {tide['direction']} at {tide['height_ft']} ft,"
+            f" with the next {extreme_type} tide of {extreme['height']:.2f} ft at {extreme_time}."
+        )
+
+    sea_temp_desc = ""
+    if surf_data.get("Sea Surface Temperature") is not None:
+        sea_temp_desc = f" The sea surface temperature is {surf_data['Sea Surface Temperature']} {unit_label}."
+
     summary = (
         f"Today at {surf_data['Location']}, the surf height is "
         f"{surf_data['Height']} {surf_data['Unit']}, the direction of the "
         f"swell is {surf_data['Swell Direction']} degrees and the swell "
         f"period is {surf_data['Period']} seconds."
+        f"{sea_temp_desc}{tide_desc}"
     )
     try:
         return get_llm_client().call_llm(summary)
     except Exception as e:
         logger.error("LLM request failed: %s", e)
         return "Unable to generate GPT response."
+
+def current_tide(lat: float, long: float) -> dict:
+    predictions = api.get_tide_data(lat, long)["predictions"]
+
+    parsed = [
+        {
+            "time": datetime.strptime(p["t"], "%Y-%m-%d %H:%M").replace(tzinfo=timezone.utc),
+            "height": float(p["v"]),
+            "type": p["type"],
+        }
+        for p in predictions
+    ]
+
+    now = datetime.now(timezone.utc)   # ← tz-aware UTC
+
+    prev = next_ = None
+    for a, b in zip(parsed, parsed[1:]):
+        if a["time"] <= now <= b["time"]:
+            prev, next_ = a, b
+            break
+
+    if not prev:
+        raise ValueError("Current time outside prediction window")
+
+    span = (next_["time"] - prev["time"]).total_seconds()
+    elapsed = (now - prev["time"]).total_seconds()
+    x = elapsed / span
+    height = prev["height"] + (next_["height"] - prev["height"]) * (1 - cos(pi * x)) / 2
+
+    direction = "incoming" if next_["type"] == "H" else "outgoing"
+
+    return {
+        "height_ft": round(height, 2),
+        "direction": direction,
+        "next_extreme": {
+            "time": next_["time"].isoformat(),
+            "height": next_["height"],
+            "type": next_["type"],
+        },
+    }
+
+
+
+if __name__ == "__main__":
+    print(current_tide(32.856132, -117.2175761))

tests/test_api.py

@@ -112,7 +112,7 @@ def test_get_uv(mock_create_client):
 
 @patch("src.api.openmeteo_client")
 def test_ocean_information(mock_create_client):
-    # fake each variable (height, direction, period)
+    # fake each variable (height, direction, period, sea surface temp)
     mock_var_0 = MagicMock()
     mock_var_0.Value.return_value = 3.5
 
@@ -122,9 +122,11 @@ def test_ocean_information(mock_create_client):
     mock_var_2 = MagicMock()
     mock_var_2.Value.return_value = 12.0
 
-    # Variables(0), Variables(1), Variables(2) return different mocks
+    mock_var_3 = MagicMock()
+    mock_var_3.Value.return_value = 20.0
+
     mock_current = MagicMock()
-    mock_current.Variables.side_effect = [mock_var_0, mock_var_1, mock_var_2]
+    mock_current.Variables.side_effect = [mock_var_0, mock_var_1, mock_var_2, mock_var_3]
 
     mock_response = MagicMock()
     mock_response.Current.return_value = mock_current
@@ -133,7 +135,7 @@ def test_ocean_information(mock_create_client):
 
     result = ocean_information(31.41, -84.92, 2, "imperial")
 
-    assert result == [3.5, 180.0, 12.0]
+    assert result == [3.5, 180.0, 12.0, 20.0]
 
 
 @patch("src.api.openmeteo_client")
@@ -176,7 +178,7 @@ def test_forecast(mock_create_client):
     assert len(fc["wave_period_max"]) == FORECAST_LENGTH
 
 
-@patch("src.api.ocean_information", return_value=[3.5, 180.0, 12.0])
+@patch("src.api.ocean_information", return_value=[3.5, 180.0, 12.0, 20.0])
 @patch("src.api.get_uv", return_value=5.0)
 @patch(
     "src.api.get_hourly_forecast",
@@ -190,7 +192,9 @@ def test_forecast(mock_create_client):
 )
 @patch("src.api.get_uv_history", return_value="5.0")
 @patch("src.helper.forecast_to_json", return_value={})
+@patch("src.api._safe_current_tide", return_value=None)
 def test_gather_data(  # noqa: PLR0913, PLR0917
+    mock_tide,
     mock_ftj,
     mock_uv_hist,
     mock_ocean_hist,