Claude Code + Gigabrain

import os
import requests
import json
from datetime import datetime
from dotenv import load_dotenv

load_dotenv()

API_KEY = os.getenv("GIGABRAIN_API_KEY")
BASE_URL = "https://api.gigabrain.gg"

class SentimentAnalyzer:
def **init**(self):
self.session = requests.Session()
self.session.headers.update({
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
})

    def query_gigabrain(self, message):
        """Query Gigabrain API with error handling"""
        try:
            response = self.session.post(
                f"{BASE_URL}/v1/chat",
                json={"message": message},
                timeout=600
            )

            if response.status_code == 200:
                data = response.json()
                return json.loads(data["content"])
            elif response.status_code == 429:
                retry_after = int(response.headers.get("Retry-After", 60))
                print(f"⏳ Rate limited. Waiting {retry_after}s...")
                import time
                time.sleep(retry_after)
                return self.query_gigabrain(message)
            else:
                raise Exception(f"API Error {response.status_code}: {response.text}")
        except Exception as e:
            print(f"❌ Error: {e}")
            return None

    def get_fear_greed(self):
        """Fetch Fear & Greed Index"""
        query = """
        Get BTC fear and greed index. Respond as JSON with:
        fear_greed_index, fear_greed_label, btc_dominance,
        altcoin_season_index, market_cap_total, market_cap_change_24h
        """
        return self.query_gigabrain(query)

    def get_funding_sentiment(self):
        """Analyze funding rates for sentiment"""
        query = """
        Get funding rates for BTC, ETH, SOL. Respond as JSON array with:
        symbol, funding_rate, open_interest, long_short_ratio
        """
        return self.query_gigabrain(query)

    def get_narratives(self):
        """Fetch trending narratives"""
        query = """
        Get current crypto narratives ranked by momentum. Respond as JSON array with:
        narrative, momentum_score, top_tokens, sentiment
        """
        return self.query_gigabrain(query)

    def calculate_regime_score(self, fear_greed, funding, narratives):
        """Calculate overall market regime score (0-100)"""
        scores = []

        # Fear & Greed contribution (0-40 points)
        if fear_greed:
            fg_index = fear_greed.get("fear_greed_index", 50)
            scores.append(fg_index * 0.4)

        # Funding rate contribution (0-30 points)
        if funding:
            avg_funding = sum(abs(t["funding_rate"]) for t in funding) / len(funding)
            # High funding = extreme positioning = lower score
            funding_score = max(0, 30 - (avg_funding * 1000))
            scores.append(funding_score)

        # Narrative momentum contribution (0-30 points)
        if narratives:
            avg_momentum = sum(n["momentum_score"] for n in narratives[:3]) / 3
            scores.append(avg_momentum * 0.3)

        return sum(scores) if scores else 50

    def get_regime_label(self, score):
        """Convert score to regime label"""
        if score >= 70:
            return "🟢 RISK ON"
        elif score >= 50:
            return "🟡 NEUTRAL"
        elif score >= 30:
            return "🟠 CAUTIOUS"
        else:
            return "🔴 RISK OFF"

    def analyze(self):
        """Run complete sentiment analysis"""
        print("🧠 Gigabrain Market Sentiment Analyzer")
        print("=" * 60)
        print(f"Timestamp: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")

        # Fetch all data
        print("📊 Fetching market data...")
        fear_greed = self.get_fear_greed()
        funding = self.get_funding_sentiment()
        narratives = self.get_narratives()

        # Display results
        if fear_greed:
            print(f"\n📈 Fear & Greed Index: {fear_greed['fear_greed_index']} ({fear_greed['fear_greed_label']})")
            print(f"   BTC Dominance: {fear_greed['btc_dominance']}%")
            print(f"   Altcoin Season Index: {fear_greed['altcoin_season_index']}")

        if funding:
            print(f"\n💰 Funding Rates:")
            for token in funding:
                rate_pct = token['funding_rate'] * 100
                direction = "LONG" if rate_pct > 0 else "SHORT"
                print(f"   {token['symbol']}: {rate_pct:.4f}% ({direction} paying)")

        if narratives:
            print(f"\n🔥 Top Narratives:")
            for i, narrative in enumerate(narratives[:3], 1):
                print(f"   {i}. {narrative['narrative']} (Momentum: {narrative['momentum_score']}/100)")
                print(f"      Tokens: {', '.join(narrative['top_tokens'])}")

        # Calculate regime
        regime_score = self.calculate_regime_score(fear_greed, funding, narratives)
        regime_label = self.get_regime_label(regime_score)

        print(f"\n{'=' * 60}")
        print(f"🎯 MARKET REGIME: {regime_label}")
        print(f"   Score: {regime_score:.1f}/100")
        print(f"{'=' * 60}")

        return {
            "timestamp": datetime.now().isoformat(),
            "regime_score": regime_score,
            "regime_label": regime_label,
            "fear_greed": fear_greed,
            "funding": funding,
            "narratives": narratives
        }

if **name** == "**main**":
analyzer = SentimentAnalyzer()
result = analyzer.analyze()

    # Save to file
    with open("sentiment_report.json", "w") as f:
        json.dump(result, f, indent=2)

    print(f"\n💾 Report saved to sentiment_report.json")