Merge pull request #199 from ryansurf/feat-refactor

gpt udpates

Author: ryansurf

src/cli.py

@@ -21,9 +21,6 @@ class SurfReport:
     """
 
     def __init__(self) -> None:
-        gpt_env = settings.GPTSettings()
-        self.gpt_prompt = gpt_env.GPT_PROMPT
-        self.gpt_info = (gpt_env.API_KEY, gpt_env.GPT_MODEL)
         self.db_handler = self._init_db()
 
     @staticmethod
@@ -60,6 +57,8 @@ def run(
         if lat is None or long is None:
             lat, long = loc_lat, loc_long
 
+        assert lat is not None
+        assert long is not None
         arguments = helper.arguments_dictionary(lat, long, city, args)
         ocean_data_dict = api.gather_data(lat, long, arguments)
 
@@ -74,12 +73,11 @@ def _save_report(self, ocean_data_dict) -> None:
             except Exception:
                 logger.warning("Failed to save report to database.")
 
-    def _render_output(self, ocean_data_dict, arguments):
+    @staticmethod
+    def _render_output(ocean_data_dict, arguments):
         """Renders JSON or human-readable output based on arguments."""
         if not arguments["json_output"]:
-            response = helper.print_outputs(
-                ocean_data_dict, arguments, self.gpt_prompt, self.gpt_info
-            )
+            response = helper.print_outputs(ocean_data_dict, arguments)
             return ocean_data_dict, response
         helper.json_output(ocean_data_dict)
         return ocean_data_dict

src/gpt.py

@@ -2,42 +2,61 @@
 GPT Functions stored here
 """
 
+import io
 import logging
-from abc import ABC
-from typing import Any
+from contextlib import redirect_stdout
+from functools import lru_cache
 
-from g4f.client import Client
 from openai import OpenAI
 
+from src import settings
+
 logger = logging.getLogger(__name__)
 
+MIN_KEY_LEN = 5
+
+gpt_env = settings.GPTSettings()
+
 
-class Llm(ABC):
+class Llm:
     def __init__(self, model):
         self.model = model
-        self.client: Any = None
-
-    def call_llm(self, surf_summary, gpt_prompt) -> str | None:
-        try:
-            response = self.client.chat.completions.create(
-                model=self.model,
-                messages=[
-                    {"role": "user", "content": surf_summary + gpt_prompt}
-                ],
-            )
-            return response.choices[0].message.content
-        except Exception as e:
-            logger.error("LLM request failed: %s", e)
-            return "Unable to generate GPT response."
+        self.prompt = gpt_env.GPT_PROMPT
+
+    def call_llm(self, surf_summary) -> str | None:
+        response = self.client.chat.completions.create(
+            model=self.model,
+            messages=[{"role": "user", "content": surf_summary + self.prompt}],
+        )
+        return response.choices[0].message.content
 
 
 class FreeGpt(Llm):
     def __init__(self, model):
+        from g4f.client import Client  # noqa: PLC0415
+
         super().__init__(model)
         self.client = Client()
 
+    def call_llm(self, surf_summary) -> str | None:
+        with redirect_stdout(io.StringIO()):
+            return super().call_llm(surf_summary)
+
 
 class OpenAILlm(Llm):
     def __init__(self, api_key, model):
         super().__init__(model)
         self.client = OpenAI(api_key=api_key)
+
+
+def _create_llm_client() -> Llm:
+    gpt_api_key = gpt_env.API_KEY
+    gpt_model = gpt_env.GPT_MODEL
+    if not gpt_api_key or len(gpt_api_key) < MIN_KEY_LEN:
+        return FreeGpt(gpt_model)
+    return OpenAILlm(api_key=gpt_api_key, model=gpt_model)
+
+
+@lru_cache(maxsize=1)
+def get_llm_client() -> Llm:
+    return _create_llm_client()

src/helper.py

@@ -5,7 +5,8 @@
 import json
 import logging
 
-from src import api, art, gpt
+from src import api, art
+from src.gpt import get_llm_client
 
 logger = logging.getLogger(__name__)
 
@@ -294,7 +295,7 @@ def json_output(data_dict, print_output=True):
     return data_dict
 
 
-def print_outputs(ocean_data_dict, arguments, gpt_prompt, gpt_info):
+def print_outputs(ocean_data_dict, arguments):
     """
     Main printing function; calls all the other printing functions.
     """
@@ -322,7 +323,7 @@ def print_outputs(ocean_data_dict, arguments, gpt_prompt, gpt_info):
 
     gpt_response = None
     if arguments["gpt"]:
-        gpt_response = print_gpt(ocean_data_dict, gpt_prompt, gpt_info)
+        gpt_response = get_gpt_response(ocean_data_dict)
         print(gpt_response)
     return gpt_response
 
@@ -377,7 +378,7 @@ def forecast_to_json(forecast_data, decimal):
     return forecasts
 
 
-def print_gpt(surf_data, gpt_prompt, gpt_info):
+def get_gpt_response(surf_data):
     """
     Builds a surf summary and returns the GPT response.
     """
@@ -387,8 +388,8 @@ def print_gpt(surf_data, gpt_prompt, gpt_info):
         f"swell is {surf_data['Swell Direction']} degrees and the swell "
         f"period is {surf_data['Period']} seconds."
     )
-    api_key, gpt_model = gpt_info
-    MIN_KEY_LEN = 5
-    if not api_key or len(api_key) < MIN_KEY_LEN:
-        return gpt.FreeGpt(gpt_model).call_llm(summary, gpt_prompt)
-    return gpt.OpenAILlm(api_key, gpt_model).call_llm(summary, gpt_prompt)
+    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."

src/open_meteo.py

@@ -5,8 +5,11 @@
 
 def _create_client() -> openmeteo_requests.Client:
     """Creates a cached, retry-enabled Open-Meteo API client."""
+    backend = requests_cache.SQLiteCache(
+        "/tmp/.cache", use_memory=False, wal=True
+    )
     cache_session = requests_cache.CachedSession(
-        "/tmp/.cache", expire_after=3600
+        backend=backend, expire_after=3600
     )
     retry_session = retry(cache_session, retries=5, backoff_factor=0.2)
     return openmeteo_requests.Client(session=retry_session)

tests/conftest.py

@@ -0,0 +1,9 @@
+"""
+Pytest configuration and shared fixtures.
+"""
+
+from unittest.mock import MagicMock, patch
+
+# Prevent g4f from loading its C extensions (curl_cffi/eventlet) during tests,
+# which cause segfaults when mixed with the test runner's event loop.
+patch("g4f.client.Client", MagicMock()).start()

tests/test_cli.py

@@ -67,14 +67,6 @@ def _mock_run_pipeline(mocker, arguments, ocean_data):
 # ---------------------------------------------------------------------------
 
 
-def test_init_stores_gpt_settings(mocker):
-    """SurfReport reads GPT prompt and model from settings on construction."""
-    _mock_settings(mocker, gpt_prompt="surf report", api_key="", model="gpt-4")
-    report = SurfReport()
-    assert report.gpt_prompt == "surf report"
-    assert report.gpt_info == ("", "gpt-4")
-
-
 def test_init_db_none_when_uri_empty(mocker):
     """db_handler is None when DB_URI is not configured."""
     _mock_settings(mocker, db_uri="")

tests/test_gpt.py

@@ -4,6 +4,8 @@
 
 from unittest.mock import Mock
 
+import pytest
+
 from src import gpt
 
 
@@ -24,27 +26,23 @@ def test_free_gpt_returns_model_content(mocker):
     mock_client.chat.completions.create.return_value = _make_chat_response(
         "Great surf day!"
     )
-    mocker.patch("src.gpt.Client", return_value=mock_client)
+    mocker.patch("g4f.client.Client", return_value=mock_client)
 
-    result = gpt.FreeGpt("gpt-3.5-turbo").call_llm(
-        "surf is 4ft", "what board should I ride?"
-    )
+    result = gpt.FreeGpt("gpt-3.5-turbo").call_llm("surf is 4ft")
 
     assert result == "Great surf day!"
     mock_client.chat.completions.create.assert_called_once()
 
 
-def test_free_gpt_returns_fallback_on_exception(mocker):
-    """FreeGpt.call_llm returns the error string when the client raises."""
+def test_free_gpt_raises_on_exception(mocker):
+    """FreeGpt.call_llm propagates exceptions to the caller."""
     mock_client = Mock()
     mock_client.chat.completions.create.side_effect = Exception("API down")
-    mocker.patch("src.gpt.Client", return_value=mock_client)
-
-    result = gpt.FreeGpt("gpt-3.5-turbo").call_llm(
-        "surf is 4ft", "what board?"
-    )
+    mocker.patch("g4f.client.Client", return_value=mock_client)
 
-    assert result == "Unable to generate GPT response."
+    llm = gpt.FreeGpt("gpt-3.5-turbo")
+    with pytest.raises(Exception, match="API down"):
+        llm.call_llm("surf is 4ft")
 
 
 def test_openai_llm_returns_model_content(mocker):
@@ -55,24 +53,20 @@ def test_openai_llm_returns_model_content(mocker):
     )
     mocker.patch("src.gpt.OpenAI", return_value=mock_client)
 
-    result = gpt.OpenAILlm("sk-testkey", "gpt-4").call_llm(
-        "surf is 2ft", "recommend a board"
-    )
+    result = gpt.OpenAILlm("sk-testkey", "gpt-4").call_llm("surf is 2ft")
 
     assert result == "Bring your longboard."
     mock_client.chat.completions.create.assert_called_once()
 
 
-def test_openai_llm_returns_fallback_on_exception(mocker):
-    """OpenAILlm.call_llm returns the error string when the client raises."""
+def test_openai_llm_raises_on_exception(mocker):
+    """OpenAILlm.call_llm propagates exceptions to the caller."""
     mock_client = Mock()
     mock_client.chat.completions.create.side_effect = Exception(
         "quota exceeded"
     )
     mocker.patch("src.gpt.OpenAI", return_value=mock_client)
 
-    result = gpt.OpenAILlm("sk-key", "gpt-4").call_llm(
-        "surf is 2ft", "recommend a board"
-    )
-
-    assert result == "Unable to generate GPT response."
+    llm = gpt.OpenAILlm("sk-key", "gpt-4")
+    with pytest.raises(Exception, match="quota exceeded"):
+        llm.call_llm("surf is 2ft")

tests/test_helper.py

@@ -347,7 +347,7 @@ def test_print_outputs_no_ocean_data(mocker, capsys):
         "color": "blue",
     }
     mocker.patch("src.api.forecast", return_value={})
-    helper.print_outputs(ocean_data, arguments, "", (None, ""))
+    helper.print_outputs(ocean_data, arguments)
     assert "No ocean data at this location." in capsys.readouterr().out
 
 
@@ -371,14 +371,17 @@ def test_print_outputs_valid_data(mocker, capsys):
         "color": "blue",
     }
     mocker.patch("src.api.forecast", return_value={})
-    helper.print_outputs(ocean_data, arguments, "", (None, ""))
+    helper.print_outputs(ocean_data, arguments)
     out = capsys.readouterr().out
     assert "Santa Cruz" in out
     assert "Wave Height: 3.0" in out
 
 
 def test_print_outputs_with_gpt(mocker, capsys):
-    """print_outputs calls print_gpt and prints its response when gpt=True."""
+    """
+    print_outputs calls get_gpt_response
+    and prints its response when gpt=True.
+    """
     ocean_data = {
         "Height": 3.0,
         "Lat": 36.97,
@@ -398,9 +401,11 @@ def test_print_outputs_with_gpt(mocker, capsys):
         "gpt": True,
     }
     mocker.patch("src.api.forecast", return_value={})
-    mocker.patch("src.helper.print_gpt", return_value="GPT says: go surf!")
+    mocker.patch(
+        "src.helper.get_gpt_response", return_value="GPT says: go surf!"
+    )
 
-    result = helper.print_outputs(ocean_data, arguments, "prompt", (None, ""))
+    result = helper.print_outputs(ocean_data, arguments)
 
     assert result == "GPT says: go surf!"
     assert "GPT says: go surf!" in capsys.readouterr().out
@@ -421,12 +426,12 @@ def test_set_location_unpacks_dict():
 
 
 # ---------------------------------------------------------------------------
-# print_gpt
+# get_gpt_response
 # ---------------------------------------------------------------------------
 
 
-def test_print_gpt_uses_openai_when_key_is_long_enough(mocker):
-    """print_gpt uses OpenAILlm when the API key is at least 5 chars."""
+def test_get_gpt_response_uses_openai_when_key_is_long_enough(mocker):
+    """get_gpt_response uses OpenAILlm when the API key is at least 5 chars."""
     surf_data = {
         "Location": "Santa Cruz",
         "Height": "3",
@@ -436,9 +441,7 @@ def test_print_gpt_uses_openai_when_key_is_long_enough(mocker):
     }
     mock_llm = mocker.MagicMock()
     mock_llm.call_llm.return_value = "openai response"
-    mocker.patch("src.helper.gpt.OpenAILlm", return_value=mock_llm)
-    result = helper.print_gpt(
-        surf_data, "any prompt", ("sk-validkey", "gpt-4")
-    )
+    mocker.patch("src.helper.get_llm_client", return_value=mock_llm)
+    result = helper.get_gpt_response(surf_data)
     assert result == "openai response"
     mock_llm.call_llm.assert_called_once()