Merge pull request #198 from ryansurf/feat-art

Feat art

Author: ryansurf

poetry.lock

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cli-surf"
-version = "2.3.1"
+version = "2.4.0"
 description = "Command-line surf report tool"
 license = "MIT"
 authors = ["ryansurf <your@email.com>"] # TODO: email
@@ -50,6 +50,7 @@ httpx = "^0.28.1"
 debugpy = "^1.8.20"
 cachetools = "^7.0.5"
 mangum = "^0.21.0"
+nest-asyncio = "^1.6.0"
 
 [tool.poetry.group.dev.dependencies]
 # command: `poetry add --group dev <package-name>`

pyproject.toml

@@ -27,6 +27,40 @@
     "bold_white": "\033[1;37m",
 }
 
+ANSI_TO_CSS = {
+    "\033[0;31m": "color:#e06c75",  # red
+    "\033[0;32m": "color:#98c379",  # green
+    "\033[0;33m": "color:#e5c07b",  # yellow
+    "\033[0;34m": "color:#61afef",  # blue
+    "\033[0;35m": "color:#c678dd",  # purple
+    "\033[0;36m": "color:#56b6c2",  # teal
+    "\033[0;94m": "color:#82aaff",  # light_blue
+    "\033[0;37m": "color:#abb2bf",  # white
+    "\033[1;31m": "color:#e06c75;font-weight:bold",
+    "\033[1;32m": "color:#98c379;font-weight:bold",
+    "\033[1;33m": "color:#e5c07b;font-weight:bold",
+    "\033[1;34m": "color:#61afef;font-weight:bold",
+    "\033[1;35m": "color:#c678dd;font-weight:bold",
+    "\033[1;36m": "color:#56b6c2;font-weight:bold",
+    "\033[1;37m": "color:#abb2bf;font-weight:bold",
+    "\033[39m": "color:inherit",  # default
+    "\033[0m": None,  # reset → close span
+}
+
+
+def ansi_to_html(text: str) -> str:
+    html = text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+    for code, css in ANSI_TO_CSS.items():
+        if css is not None:
+            html = html.replace(code, f'<span style="{css}">')
+        else:
+            html = html.replace(code, "</span>")
+    return f"""
+        <pre style="padding:1em;font-family:monospace;line-height:1.4">
+            {html}
+        </pre>
+        """
+
 
 def print_wave(show_wave, show_large_wave, color):
     """

src/art.py

@@ -3,52 +3,41 @@
 """
 
 import logging
+from abc import ABC
+from typing import Any
 
 from g4f.client import Client
 from openai import OpenAI
 
 logger = logging.getLogger(__name__)
 
 
-def simple_gpt(surf_summary, gpt_prompt):
-    """
-    Surf summary is a report of todays data, ex: The surf is 4
-    feet with a 10 second period... GPT Prompt is what kind of
-    report the user wants, loaded in from the environment vars
-    Using: https://github.com/xtekky/gpt4free
-    """
-    try:
-        client = Client()
-        response = client.chat.completions.create(
-            model="gpt-3.5-turbo",
-            messages=[{"role": "user", "content": surf_summary + gpt_prompt}],
-        )
-        return response.choices[0].message.content
-    except Exception as e:
-        logger.error("GPT (free) request failed: %s", e)
-        return "Unable to generate GPT response."
-
-
-def openai_gpt(surf_summary, gpt_prompt, api_key, model):
-    """
-    Surf Summary is a brief summary of the surf data(height, period)
-    and gpt_prompt is the personal report the user wants(reccomend a
-    board, etc). gpt_prompt in .env
-    Uses openai's GPT, needs an API key
-    https://platform.openai.com/docs/api-reference/introduction
-    """
-    try:
-        client = OpenAI(api_key=api_key)
-        chat_completion = client.chat.completions.create(
-            messages=[
-                {
-                    "role": "user",
-                    "content": surf_summary + gpt_prompt,
-                }
-            ],
-            model=model,
-        )
-        return chat_completion.choices[0].message.content
-    except Exception as e:
-        logger.error("OpenAI request failed: %s", e)
-        return "Unable to generate GPT response."
+class Llm(ABC):
+    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."
+
+
+class FreeGpt(Llm):
+    def __init__(self, model):
+        super().__init__(model)
+        self.client = Client()
+
+
+class OpenAILlm(Llm):
+    def __init__(self, api_key, model):
+        super().__init__(model)
+        self.client = OpenAI(api_key=api_key)

src/gpt.py

@@ -390,5 +390,5 @@ def print_gpt(surf_data, gpt_prompt, gpt_info):
     api_key, gpt_model = gpt_info
     MIN_KEY_LEN = 5
     if not api_key or len(api_key) < MIN_KEY_LEN:
-        return gpt.simple_gpt(summary, gpt_prompt)
-    return gpt.openai_gpt(summary, gpt_prompt, api_key, gpt_model)
+        return gpt.FreeGpt(gpt_model).call_llm(summary, gpt_prompt)
+    return gpt.OpenAILlm(api_key, gpt_model).call_llm(summary, gpt_prompt)

src/helper.py

@@ -10,10 +10,11 @@
 import uvicorn
 from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import FileResponse, PlainTextResponse
+from fastapi.responses import FileResponse, HTMLResponse, PlainTextResponse
 from fastapi.templating import Jinja2Templates
 
 from src import cli
+from src.art import ansi_to_html
 from src.settings import ServerSettings
 
 logger = logging.getLogger(__name__)
@@ -63,7 +64,12 @@ async def default_route(request: Request):
         f = io.StringIO()
         with redirect_stdout(f):
             surf.run(args=passed_args)
-        return f.getvalue()
+        output = f.getvalue()
+
+        accept = request.headers.get("accept", "")
+        if "text/html" in accept:
+            return HTMLResponse(content=ansi_to_html(output))
+        return PlainTextResponse(output)
 
     return app
 

src/server.py

@@ -18,51 +18,61 @@ def _make_chat_response(content):
     return response
 
 
-def test_simple_gpt_returns_model_content(mocker):
-    """simple_gpt returns the text content from the g4f response."""
+def test_free_gpt_returns_model_content(mocker):
+    """FreeGpt.call_llm returns the text content from the g4f response."""
     mock_client = Mock()
     mock_client.chat.completions.create.return_value = _make_chat_response(
         "Great surf day!"
     )
     mocker.patch("src.gpt.Client", return_value=mock_client)
 
-    result = gpt.simple_gpt("surf is 4ft", "what board should I ride?")
+    result = gpt.FreeGpt("gpt-3.5-turbo").call_llm(
+        "surf is 4ft", "what board should I ride?"
+    )
 
     assert result == "Great surf day!"
     mock_client.chat.completions.create.assert_called_once()
 
 
-def test_simple_gpt_returns_fallback_on_exception(mocker):
-    """simple_gpt returns the error string when the g4f client raises."""
-    mocker.patch("src.gpt.Client", side_effect=Exception("API down"))
+def test_free_gpt_returns_fallback_on_exception(mocker):
+    """FreeGpt.call_llm returns the error string when the client raises."""
+    mock_client = Mock()
+    mock_client.chat.completions.create.side_effect = Exception("API down")
+    mocker.patch("src.gpt.Client", return_value=mock_client)
 
-    result = gpt.simple_gpt("surf is 4ft", "what board?")
+    result = gpt.FreeGpt("gpt-3.5-turbo").call_llm(
+        "surf is 4ft", "what board?"
+    )
 
     assert result == "Unable to generate GPT response."
 
 
-def test_openai_gpt_returns_model_content(mocker):
-    """openai_gpt returns the text content from the OpenAI response."""
+def test_openai_llm_returns_model_content(mocker):
+    """OpenAILlm.call_llm returns the text content from the OpenAI response."""
     mock_client = Mock()
     mock_client.chat.completions.create.return_value = _make_chat_response(
         "Bring your longboard."
     )
     mocker.patch("src.gpt.OpenAI", return_value=mock_client)
 
-    result = gpt.openai_gpt(
-        "surf is 2ft", "recommend a board", "sk-testkey", "gpt-4"
+    result = gpt.OpenAILlm("sk-testkey", "gpt-4").call_llm(
+        "surf is 2ft", "recommend a board"
     )
 
     assert result == "Bring your longboard."
     mock_client.chat.completions.create.assert_called_once()
 
 
-def test_openai_gpt_returns_fallback_on_exception(mocker):
-    """openai_gpt returns the error string when the OpenAI client raises."""
-    mocker.patch("src.gpt.OpenAI", side_effect=Exception("quota exceeded"))
+def test_openai_llm_returns_fallback_on_exception(mocker):
+    """OpenAILlm.call_llm returns the error string when the client raises."""
+    mock_client = Mock()
+    mock_client.chat.completions.create.side_effect = Exception(
+        "quota exceeded"
+    )
+    mocker.patch("src.gpt.OpenAI", return_value=mock_client)
 
-    result = gpt.openai_gpt(
-        "surf is 2ft", "recommend a board", "sk-key", "gpt-4"
+    result = gpt.OpenAILlm("sk-key", "gpt-4").call_llm(
+        "surf is 2ft", "recommend a board"
     )
 
     assert result == "Unable to generate GPT response."

tests/test_gpt.py

@@ -426,19 +426,19 @@ def test_set_location_unpacks_dict():
 
 
 def test_print_gpt_uses_openai_when_key_is_long_enough(mocker):
-    """print_gpt calls openai_gpt when the API key is at least 5 chars."""
+    """print_gpt uses OpenAILlm when the API key is at least 5 chars."""
     surf_data = {
         "Location": "Santa Cruz",
         "Height": "3",
         "Swell Direction": "270",
         "Period": "12",
         "Unit": "ft",
     }
-    mock_openai = mocker.patch(
-        "src.helper.gpt.openai_gpt", return_value="openai response"
-    )
+    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")
     )
     assert result == "openai response"
-    mock_openai.assert_called_once()
+    mock_llm.call_llm.assert_called_once()