Harden Adanos sentiment integration

Author: alexander-schneider

backend_api_python/README.md

@@ -201,6 +201,12 @@ Example:
 GET /api/global-market/adanos-sentiment?tickers=AAPL,TSLA&source=reddit&days=7
 ```
 
+The response normalizes common compare fields across sources, including
+`sentiment_score`, `buzz_score`, `bullish_pct`, `bearish_pct`, `mentions`,
+`trend`, `trend_history`, and source-specific activity metrics such as
+`subreddit_count`, `unique_tweets`, `source_count`, `trade_count`,
+`market_count`, and `total_liquidity`.
+
 ## AI analysis & memory
 
 Uses **FastAnalysisService** (single LLM call, multi-factor):

backend_api_python/app/data_providers/adanos_sentiment.py

@@ -1,6 +1,7 @@
 """Optional Adanos Market Sentiment provider for US stock tickers."""
 from __future__ import annotations
 
+import math
 import os
 import re
 from typing import Any, Dict, Iterable, List, Optional
@@ -28,8 +29,11 @@
 _TICKER_RE = re.compile(r"^\$?[A-Z][A-Z0-9.]{0,9}$")
 
 
-def parse_tickers(value: str | Iterable[str]) -> List[str]:
+def parse_tickers(value: str | Iterable[str] | None) -> List[str]:
     """Normalize comma-separated or iterable stock ticker input."""
+    if value is None:
+        return []
+
     raw_values = value.split(",") if isinstance(value, str) else list(value)
     tickers: List[str] = []
     seen = set()
@@ -61,19 +65,32 @@ def _to_float(value: Any) -> Optional[float]:
     if value in (None, ""):
         return None
     try:
-        return float(value)
+        number = float(value)
     except (TypeError, ValueError):
         return None
+    return number if math.isfinite(number) else None
 
 
 def _to_int(value: Any) -> Optional[int]:
     number = _to_float(value)
     return int(number) if number is not None else None
 
 
-def _rows(payload: Dict[str, Any]) -> List[Dict[str, Any]]:
-    rows = payload.get("stocks") or payload.get("data") or payload.get("results") or []
-    return rows if isinstance(rows, list) else []
+def _pick(record: Dict[str, Any], *keys: str) -> Any:
+    for key in keys:
+        if key in record:
+            return record.get(key)
+    return None
+
+
+def _rows(payload: Any) -> List[Dict[str, Any]]:
+    if isinstance(payload, list):
+        rows = payload
+    elif isinstance(payload, dict):
+        rows = payload.get("stocks") or payload.get("data") or payload.get("results") or []
+    else:
+        rows = []
+    return [row for row in rows if isinstance(row, dict)] if isinstance(rows, list) else []
 
 
 def _normalize_record(record: Dict[str, Any], source: str) -> Optional[Dict[str, Any]]:
@@ -83,18 +100,24 @@ def _normalize_record(record: Dict[str, Any], source: str) -> Optional[Dict[str,
 
     return {
         "ticker": ticker,
-        "company_name": record.get("company_name"),
+        "company_name": _pick(record, "company_name", "name", "company"),
         "source": source,
-        "sentiment_score": _to_float(record.get("sentiment_score", record.get("sentiment", record.get("score")))),
-        "buzz_score": _to_float(record.get("buzz_score", record.get("buzz"))),
+        "sentiment_score": _to_float(_pick(record, "sentiment_score", "sentiment", "score")),
+        "buzz_score": _to_float(_pick(record, "buzz_score", "buzz")),
         "bullish_pct": _to_float(record.get("bullish_pct")),
         "bearish_pct": _to_float(record.get("bearish_pct")),
-        "mentions": _to_int(record.get("mentions")),
+        "mentions": _to_int(_pick(record, "mentions", "mention_count")),
         "source_count": _to_int(record.get("source_count")),
         "subreddit_count": _to_int(record.get("subreddit_count")),
-        "trade_count": _to_int(record.get("trade_count")),
+        "unique_posts": _to_int(record.get("unique_posts")),
         "unique_tweets": _to_int(record.get("unique_tweets")),
+        "trade_count": _to_int(record.get("trade_count")),
+        "market_count": _to_int(record.get("market_count")),
+        "unique_traders": _to_int(record.get("unique_traders")),
+        "total_upvotes": _to_int(_pick(record, "total_upvotes", "upvotes")),
+        "total_liquidity": _to_float(record.get("total_liquidity")),
         "trend": record.get("trend"),
+        "trend_history": record.get("trend_history") if isinstance(record.get("trend_history"), list) else [],
     }
 
 
@@ -110,7 +133,7 @@ def _timeout() -> int:
 
 
 def fetch_adanos_market_sentiment(
-    tickers: str | Iterable[str],
+    tickers: str | Iterable[str] | None,
     *,
     source: Optional[str] = None,
     days: int = DEFAULT_DAYS,

backend_api_python/tests/test_data_providers.py

@@ -61,7 +61,10 @@ def json():
                         "buzz_score": "72.5",
                         "bullish_pct": "58",
                         "mentions": "128",
+                        "unique_posts": "32",
+                        "total_upvotes": "1204",
                         "trend": "rising",
+                        "trend_history": [45.0, 51.5, 72.5],
                     }
                 ]
             }
@@ -94,9 +97,15 @@ def get(url, **kwargs):
         "mentions": 128,
         "source_count": None,
         "subreddit_count": None,
-        "trade_count": None,
+        "unique_posts": 32,
         "unique_tweets": None,
+        "trade_count": None,
+        "market_count": None,
+        "unique_traders": None,
+        "total_upvotes": 1204,
+        "total_liquidity": None,
         "trend": "rising",
+        "trend_history": [45.0, 51.5, 72.5],
     }
     assert calls[0][0] == "https://api.example.test/reddit/stocks/v1/compare"
     assert calls[0][1]["params"] == {"tickers": "AAPL", "days": 14}
@@ -122,6 +131,58 @@ def get(url, **kwargs):
     assert result["error"] == "Adanos API returned HTTP 429"
 
 
+def test_adanos_sentiment_handles_list_payload_and_non_finite_numbers():
+    from app.data_providers.adanos_sentiment import fetch_adanos_market_sentiment
+
+    class FakeResponse:
+        status_code = 200
+
+        @staticmethod
+        def json():
+            return [
+                {
+                    "symbol": "$MSFT",
+                    "name": "Microsoft Corp.",
+                    "sentiment": "NaN",
+                    "buzz": "inf",
+                    "mentions": "bad",
+                    "market_count": "3",
+                    "total_liquidity": "45200.5",
+                    "trend_history": [12.0, 18.5],
+                },
+                "not-a-row",
+                {},
+            ]
+
+    class FakeSession:
+        @staticmethod
+        def get(url, **kwargs):
+            return FakeResponse()
+
+    result = fetch_adanos_market_sentiment(
+        None,
+        api_key="adanos_test_key",
+        session=FakeSession,
+    )
+    assert result["stocks"] == []
+    assert result["error"] == "No valid stock tickers provided"
+
+    result = fetch_adanos_market_sentiment(
+        "MSFT",
+        api_key="adanos_test_key",
+        session=FakeSession,
+    )
+
+    assert result["stocks"][0]["ticker"] == "MSFT"
+    assert result["stocks"][0]["company_name"] == "Microsoft Corp."
+    assert result["stocks"][0]["sentiment_score"] is None
+    assert result["stocks"][0]["buzz_score"] is None
+    assert result["stocks"][0]["mentions"] is None
+    assert result["stocks"][0]["market_count"] == 3
+    assert result["stocks"][0]["total_liquidity"] == 45200.5
+    assert result["stocks"][0]["trend_history"] == [12.0, 18.5]
+
+
 def test_adanos_sentiment_validates_source():
     import pytest
     from app.data_providers.adanos_sentiment import normalize_source

backend_api_python/tests/test_global_market_adanos.py

@@ -0,0 +1,65 @@
+"""Tests for the optional Adanos global-market endpoint."""
+
+
+def _auth_headers(monkeypatch):
+    from app.utils import auth
+
+    monkeypatch.setattr(
+        auth,
+        "verify_token",
+        lambda token: {
+            "sub": "tester",
+            "user_id": 1,
+            "role": "user",
+            "token_version": 1,
+        },
+    )
+    return {"Authorization": "Bearer test-token"}
+
+
+def test_adanos_sentiment_endpoint_requires_login(client):
+    resp = client.get("/api/global-market/adanos-sentiment?tickers=AAPL")
+
+    assert resp.status_code == 401
+    assert resp.get_json()["msg"] == "Token missing"
+
+
+def test_adanos_sentiment_endpoint_returns_provider_result(client, monkeypatch):
+    from app.routes import global_market
+
+    calls = []
+
+    def fake_fetch(tickers, *, source=None, days=7):
+        calls.append({"tickers": tickers, "source": source, "days": days})
+        return {
+            "enabled": False,
+            "provider": "adanos",
+            "source": source,
+            "days": days,
+            "tickers": ["AAPL", "TSLA"],
+            "stocks": [],
+            "error": "ADANOS_API_KEY is not configured",
+        }
+
+    monkeypatch.setattr(global_market, "fetch_adanos_market_sentiment", fake_fetch)
+
+    resp = client.get(
+        "/api/global-market/adanos-sentiment?tickers=aapl,$tsla&source=x&days=14",
+        headers=_auth_headers(monkeypatch),
+    )
+
+    assert resp.status_code == 200
+    body = resp.get_json()
+    assert body["code"] == 1
+    assert body["data"]["enabled"] is False
+    assert calls == [{"tickers": "aapl,$tsla", "source": "x", "days": 14}]
+
+
+def test_adanos_sentiment_endpoint_rejects_invalid_days(client, monkeypatch):
+    resp = client.get(
+        "/api/global-market/adanos-sentiment?tickers=AAPL&days=bad",
+        headers=_auth_headers(monkeypatch),
+    )
+
+    assert resp.status_code == 400
+    assert resp.get_json()["code"] == 0