Creator Insights

# Creator Insights Configuration
# API keys come from environment variables: TWITTER_API_KEY, OPENROUTER_API_KEY
# All API calls route through sc-proxy for billing/tracking

openrouter:
  default_model: "openai/gpt-4o-mini"
  temperature: 0.7
  max_tokens: 2000

settings:
  rate_limit: 100
  default_timeframe: "30d"
  cache_duration: 15
  log_level: "INFO"

influence:
  follower_weight: 0.7
  engagement_weight: 0.3
  high_value_threshold: 10000
  hidden_gem_threshold: 5000
  min_engagement_interactions: 2

viral:
  min_engagement: 100
  min_likes: 500
  peak_hours:
    start: 9
    end: 15
  high_reply_ratio: 0.25
  high_retweet_ratio: 0.20
  viral_coefficient: 0.30

generation:
  num_variations: 5
  max_length: 280
  style_sample_size: 10

privacy:
  save_history: false
  history_path: "~/.creator-insights/history"

#!/usr/bin/env python3
"""
Analytics Calculator for Creator Insights
Calculates posting cadence, engagement rates, and performance metrics.
"""

import argparse
import sys
import json
from datetime import datetime, timedelta
from typing import Dict, List, Optional
from collections import defaultdict
from api_client import APIClient


class AnalyticsCalculator:
    """Calculates content performance analytics"""

    def __init__(self, api_client: APIClient):
        self.api_client = api_client

    def calculate_metrics(self, profile: str, platform: str, timeframe: str = "30d") -> Dict:
        """
        Calculate comprehensive analytics for a creator's profile.

        Args:
            profile: Username or profile URL
            platform: Social media platform
            timeframe: Analysis period (7d, 30d, 90d)

        Returns:
            Dict with posting cadence, engagement, and performance metrics
        """
        print(f"Calculating analytics for @{profile} on {platform}...", file=sys.stderr)

        # Parse timeframe
        days = self._parse_timeframe(timeframe)

        # Fetch posts within timeframe
        posts = self._fetch_posts(platform, profile, days)

        if not posts:
            return {
                "error": "No posts found or unable to fetch data",
                "suggestion": "Check API configuration or provide a different profile"
            }

        # Calculate all metrics
        metrics = {
            "profile": profile,
            "platform": platform,
            "timeframe": timeframe,
            "analysis_date": datetime.now().isoformat(),
            "posting_cadence": self._calculate_posting_cadence(posts, days),
            "engagement_metrics": self._calculate_engagement_metrics(posts),
            "content_performance": self._analyze_content_performance(posts),
            "growth_metrics": self._calculate_growth_metrics(posts),
            "audience_insights": self._analyze_audience_behavior(posts),
            "recommendations": self._generate_recommendations(posts, days)
        }

        return metrics

    def _parse_timeframe(self, timeframe: str) -> int:
        """Convert timeframe string to number of days"""
        mapping = {
            "7d": 7,
            "30d": 30,
            "90d": 90,
            "1w": 7,
            "1m": 30,
            "3m": 90
        }
        return mapping.get(timeframe.lower(), 30)

    def _fetch_posts(self, platform: str, username: str, days: int) -> List[Dict]:
        """Fetch posts from the specified timeframe"""
        # This would fetch actual posts from the API
        # For now, return a structure that scripts can populate
        posts = []

        # Example structure (to be populated by real API calls):
        # posts.append({
        #     "id": "post123",
        #     "timestamp": datetime.now().isoformat(),
        #     "type": "video",
        #     "likes": 1500,
        #     "comments": 89,
        #     "shares": 45,
        #     "views": 25000,
        #     "caption": "Check out this tutorial...",
        #     "hashtags": ["#tutorial", "#howto"]
        # })

        print(f"Note: Fetching real post data requires API authentication", file=sys.stderr)

        return posts

    def _calculate_posting_cadence(self, posts: List[Dict], days: int) -> Dict:
        """Calculate posting frequency and consistency"""
        if not posts:
            return {"frequency": "no data", "consistency_score": 0}

        post_count = len(posts)
        posts_per_week = (post_count / days) * 7

        # Calculate consistency score (0-10)
        # Based on regularity of posting
        if post_count >= 2:
            # Calculate time gaps between posts
            timestamps = []
            for post in posts:
                if "timestamp" in post:
                    try:
                        ts = datetime.fromisoformat(post["timestamp"].replace('Z', '+00:00'))
                        timestamps.append(ts)
                    except:
                        pass

            if len(timestamps) >= 2:
                timestamps.sort()
                gaps = [(timestamps[i+1] - timestamps[i]).days for i in range(len(timestamps)-1)]
                avg_gap = sum(gaps) / len(gaps) if gaps else 0
                gap_variance = sum((g - avg_gap) ** 2 for g in gaps) / len(gaps) if gaps else 0

                # Lower variance = higher consistency
                consistency_score = max(0, 10 - (gap_variance ** 0.5))
            else:
                consistency_score = 5.0  # Default for insufficient data
        else:
            consistency_score = 0

        # Determine frequency category
        if posts_per_week >= 7:
            frequency = "Daily (7+ posts/week)"
        elif posts_per_week >= 3:
            frequency = "Very Active (3-6 posts/week)"
        elif posts_per_week >= 1:
            frequency = "Active (1-2 posts/week)"
        else:
            frequency = "Occasional (<1 post/week)"

        return {
            "total_posts": post_count,
            "posts_per_week": round(posts_per_week, 1),
            "frequency": frequency,
            "consistency_score": round(consistency_score, 1),
            "days_analyzed": days
        }

    def _calculate_engagement_metrics(self, posts: List[Dict]) -> Dict:
        """Calculate engagement rates and metrics"""
        if not posts:
            return {"error": "no data"}

        total_likes = sum(post.get("likes", 0) for post in posts)
        total_comments = sum(post.get("comments", 0) for post in posts)
        total_shares = sum(post.get("shares", 0) for post in posts)
        total_views = sum(post.get("views", 0) for post in posts)

        avg_likes = total_likes / len(posts) if posts else 0
        avg_comments = total_comments / len(posts) if posts else 0
        avg_shares = total_shares / len(posts) if posts else 0
        avg_views = total_views / len(posts) if posts else 0

        # Calculate engagement rate
        # Engagement rate = (likes + comments + shares) / views * 100
        total_engagement = total_likes + total_comments + total_shares
        engagement_rate = (total_engagement / total_views * 100) if total_views > 0 else 0

        return {
            "total_engagement": total_engagement,
            "engagement_rate": round(engagement_rate, 2),
            "average_likes": round(avg_likes, 1),
            "average_comments": round(avg_comments, 1),
            "average_shares": round(avg_shares, 1),
            "average_views": round(avg_views, 1),
            "total_likes": total_likes,
            "total_comments": total_comments,
            "total_shares": total_shares,
            "total_views": total_views
        }

    def _analyze_content_performance(self, posts: List[Dict]) -> Dict:
        """Analyze which content performs best"""
        if not posts:
            return {"error": "no data"}

        # Group by content type
        type_performance = defaultdict(lambda: {"count": 0, "total_engagement": 0})

        for post in posts:
            content_type = post.get("type", "unknown")
            engagement = post.get("likes", 0) + post.get("comments", 0) + post.get("shares", 0)

            type_performance[content_type]["count"] += 1
            type_performance[content_type]["total_engagement"] += engagement

        # Calculate averages
        type_averages = {}
        for ctype, data in type_performance.items():
            avg_engagement = data["total_engagement"] / data["count"] if data["count"] > 0 else 0
            type_averages[ctype] = {
                "count": data["count"],
                "avg_engagement": round(avg_engagement, 1)
            }

        # Find best performing type
        best_type = max(type_averages.items(), key=lambda x: x[1]["avg_engagement"]) if type_averages else ("none", {})

        # Find top performing posts
        top_posts = sorted(posts, key=lambda p: p.get("likes", 0) + p.get("comments", 0) + p.get("shares", 0),
                          reverse=True)[:3]

        top_content = []
        for post in top_posts:
            engagement = post.get("likes", 0) + post.get("comments", 0) + post.get("shares", 0)
            engagement_rate = (engagement / post.get("views", 1) * 100) if post.get("views", 0) > 0 else 0

            top_content.append({
                "type": post.get("type", "unknown"),
                "caption": post.get("caption", "")[:50] + "..." if len(post.get("caption", "")) > 50 else post.get("caption", ""),
                "engagement": engagement,
                "engagement_rate": round(engagement_rate, 2),
                "likes": post.get("likes", 0),
                "comments": post.get("comments", 0)
            })

        return {
            "content_types": type_averages,
            "best_performing_type": best_type[0],
            "top_content": top_content
        }

    def _calculate_growth_metrics(self, posts: List[Dict]) -> Dict:
        """Calculate growth and reach metrics"""
        if not posts:
            return {"error": "no data"}

        # This would require historical follower data
        # For now, provide structure for growth analysis

        # Calculate reach trend (if view data available)
        if all("views" in post for post in posts):
            recent_views = sum(post["views"] for post in posts[:len(posts)//2])
            older_views = sum(post["views"] for post in posts[len(posts)//2:])

            if older_views > 0:
                views_change = ((recent_views - older_views) / older_views) * 100
            else:
                views_change = 0
        else:
            views_change = 0

        return {
            "reach_trend": f"{'+' if views_change > 0 else ''}{round(views_change, 1)}%",
            "reach_status": "growing" if views_change > 10 else "stable" if views_change > -10 else "declining",
            "note": "Growth metrics require historical follower data"
        }

    def _analyze_audience_behavior(self, posts: List[Dict]) -> Dict:
        """Analyze when audience is most active"""
        if not posts:
            return {"error": "no data"}

        # Analyze posting times and correlate with engagement
        time_engagement = defaultdict(lambda: {"posts": 0, "total_engagement": 0})

        for post in posts:
            if "timestamp" not in post:
                continue

            try:
                ts = datetime.fromisoformat(post["timestamp"].replace('Z', '+00:00'))
                hour = ts.hour
                day = ts.strftime("%A")

                # Categorize by time of day
                if 6 <= hour < 12:
                    time_period = "morning"
                elif 12 <= hour < 17:
                    time_period = "afternoon"
                elif 17 <= hour < 21:
                    time_period = "evening"
                else:
                    time_period = "night"

                engagement = post.get("likes", 0) + post.get("comments", 0) + post.get("shares", 0)

                time_engagement[time_period]["posts"] += 1
                time_engagement[time_period]["total_engagement"] += engagement
            except:
                pass

        # Calculate best times
        best_time = "afternoon/evening"  # Default
        if time_engagement:
            best_time = max(time_engagement.items(),
                          key=lambda x: x[1]["total_engagement"] / x[1]["posts"] if x[1]["posts"] > 0 else 0)[0]

        return {
            "best_posting_time": best_time,
            "time_breakdown": dict(time_engagement),
            "recommendation": f"Post during {best_time} for best engagement"
        }

    def _generate_recommendations(self, posts: List[Dict], days: int) -> List[str]:
        """Generate actionable recommendations based on analytics"""
        recommendations = []

        if not posts:
            return ["Unable to generate recommendations without post data"]

        post_count = len(posts)
        posts_per_week = (post_count / days) * 7

        # Posting frequency recommendations
        if posts_per_week < 1:
            recommendations.append("Increase posting frequency to at least 1-2 posts per week for better reach")
        elif posts_per_week > 10:
            recommendations.append("Consider reducing posting frequency to focus on quality over quantity")

        # Engagement recommendations
        engagement_metrics = self._calculate_engagement_metrics(posts)
        if engagement_metrics.get("engagement_rate", 0) < 2:
            recommendations.append("Engagement rate is below average - try more interactive content (polls, questions, calls-to-action)")

        # Content type recommendations
        content_perf = self._analyze_content_performance(posts)
        if content_perf.get("best_performing_type") and content_perf["best_performing_type"] != "unknown":
            recommendations.append(f"Focus more on {content_perf['best_performing_type']} content - it performs best for your audience")

        # General recommendations
        recommendations.append("Analyze trending content in your niche and adapt successful patterns")
        recommendations.append("Engage with your audience by responding to comments promptly")

        return recommendations


def main():
    """CLI interface for Twitter analytics calculator"""
    parser = argparse.ArgumentParser(description="Calculate Twitter analytics and metrics")
    parser.add_argument("--profile", required=True, help="Twitter username or URL")
    parser.add_argument("--timeframe", default="30d",
                       choices=["7d", "30d", "90d"],
                       help="Analysis timeframe")
    parser.add_argument("--output", choices=['json', 'text'], default='text',
                       help="Output format")

    args = parser.parse_args()

    # Initialize API client and calculator
    api_client = APIClient()
    calculator = AnalyticsCalculator(api_client)

    # Calculate metrics
    result = calculator.calculate_metrics(args.profile, "twitter", args.timeframe)

    # Output results
    if args.output == 'json':
        print(json.dumps(result, indent=2))
    else:
        if "error" in result:
            print(f"Error: {result['error']}", file=sys.stderr)
            if "suggestion" in result:
                print(f"Suggestion: {result['suggestion']}", file=sys.stderr)
            sys.exit(1)

        print(f"\n{'='*60}")
        print(f"TWITTER ANALYTICS: @{result['profile']}")
        print(f"Timeframe: {result['timeframe']}")
        print(f"{'='*60}\n")

        # Posting Cadence
        cadence = result["posting_cadence"]
        print("POSTING CADENCE")
        print("-" * 40)
        print(f"Total Posts: {cadence['total_posts']}")
        print(f"Posts per Week: {cadence['posts_per_week']}")
        print(f"Frequency: {cadence['frequency']}")
        print(f"Consistency Score: {cadence['consistency_score']}/10\n")

        # Engagement Metrics
        engagement = result["engagement_metrics"]
        if "error" not in engagement:
            print("ENGAGEMENT METRICS")
            print("-" * 40)
            print(f"Engagement Rate: {engagement['engagement_rate']}%")
            print(f"Average Likes: {engagement['average_likes']}")
            print(f"Average Comments: {engagement['average_comments']}")
            print(f"Average Shares: {engagement['average_shares']}")
            print(f"Average Views: {engagement['average_views']}\n")

        # Content Performance
        performance = result["content_performance"]
        if "error" not in performance:
            print("CONTENT PERFORMANCE")
            print("-" * 40)
            print(f"Best Performing Type: {performance['best_performing_type']}")
            print("\nTop Content:")
            for i, content in enumerate(performance['top_content'], 1):
                print(f"{i}. {content['caption']}")
                print(f"   Type: {content['type']} | Engagement: {content['engagement']} ({content['engagement_rate']}%)")
            print()

        # Audience Insights
        audience = result["audience_insights"]
        if "error" not in audience:
            print("AUDIENCE INSIGHTS")
            print("-" * 40)
            print(f"Best Posting Time: {audience['best_posting_time']}")
            print(f"Recommendation: {audience['recommendation']}\n")

        # Recommendations
        print("RECOMMENDATIONS")
        print("-" * 40)
        for i, rec in enumerate(result["recommendations"], 1):
            print(f"{i}. {rec}")
        print()


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Twitter API Client for Creator Insights
Provides access to Twitter/X data via TwitterAPI.io.
"""

import os
import sys
import json
import time
import requests
from typing import Dict, List, Optional, Any, Tuple
from pathlib import Path
from datetime import datetime, timedelta

class APIClient:
    """Twitter API client using TwitterAPI.io via sc-proxy"""

    def __init__(self):
        """
        Initialize API client.

        Requires TWITTER_API_KEY environment variable.
        Uses proxied HTTP client for billing/tracking through sc-proxy.
        """
        self.api_key = os.environ.get("TWITTER_API_KEY", "")
        if not self.api_key:
            print("Warning: TWITTER_API_KEY not set in environment", file=sys.stderr)

        # Rate limiting tracking
        self.rate_limits = {}

    # ============== Date Filtering Helpers ==============

    @staticmethod
    def parse_relative_date(relative_str: str) -> datetime:
        """
        Parse relative date strings like '24h', '7d', 'this week' into datetime.

        Args:
            relative_str: Relative date string (24h, 7d, 30d, this week, this month)

        Returns:
            datetime object

        Examples:
            '24h' -> 24 hours ago
            '7d' -> 7 days ago
            'this week' -> Monday of this week at 00:00
        """
        now = datetime.now()

        # Handle hour format: 24h, 48h
        if relative_str.endswith('h'):
            hours = int(relative_str[:-1])
            return now - timedelta(hours=hours)

        # Handle day format: 7d, 30d
        if relative_str.endswith('d'):
            days = int(relative_str[:-1])
            return now - timedelta(days=days)

        # Handle week format: 1w, 2w
        if relative_str.endswith('w'):
            weeks = int(relative_str[:-1])
            return now - timedelta(weeks=weeks)

        # Handle special keywords
        if relative_str.lower() == 'today':
            return now.replace(hour=0, minute=0, second=0, microsecond=0)

        if relative_str.lower() in ['this week', 'week']:
            # Go to Monday of this week
            days_since_monday = now.weekday()
            return (now - timedelta(days=days_since_monday)).replace(hour=0, minute=0, second=0, microsecond=0)

        if relative_str.lower() in ['this month', 'month']:
            return now.replace(day=1, hour=0, minute=0, second=0, microsecond=0)

        # If it's a date string, try parsing it
        try:
            return datetime.fromisoformat(relative_str)
        except:
            pass

        # Default: 24 hours ago
        return now - timedelta(hours=24)

    @staticmethod
    def format_twitter_date(dt: datetime, timezone: str = "UTC") -> str:
        """
        Format datetime for Twitter advanced search (since: / until: operators).

        Args:
            dt: datetime object
            timezone: Timezone abbreviation (default: UTC)

        Returns:
            Formatted string: "YYYY-MM-DD_HH:MM:SS_UTC"

        Example:
            datetime(2025, 3, 29, 12, 0, 0) -> "2025-03-29_12:00:00_UTC"
        """
        return dt.strftime(f"%Y-%m-%d_%H:%M:%S_{timezone}")

    @staticmethod
    def build_time_filtered_query(base_query: str, since: Optional[str] = None,
                                  until: Optional[str] = None) -> str:
        """
        Build Twitter search query with time filters.

        Args:
            base_query: Base search terms (e.g., "AI" OR "machine learning")
            since: Since date/time (relative or absolute)
            until: Until date/time (relative or absolute)

        Returns:
            Query string with since:/until: operators

        Examples:
            ("AI", "24h", None) -> "AI since:2025-03-29_12:00:00_UTC"
            ("crypto", "7d", "today") -> "crypto since:2025-03-22_00:00:00_UTC until:2025-03-30_00:00:00_UTC"
        """
        query_parts = [base_query]

        if since:
            since_dt = APIClient.parse_relative_date(since)
            since_formatted = APIClient.format_twitter_date(since_dt)
            query_parts.append(f"since:{since_formatted}")

        if until:
            until_dt = APIClient.parse_relative_date(until)
            until_formatted = APIClient.format_twitter_date(until_dt)
            query_parts.append(f"until:{until_formatted}")

        return " ".join(query_parts)

    @staticmethod
    def filter_tweets_by_date(tweets: List[Dict], since: Optional[str] = None,
                             until: Optional[str] = None) -> List[Dict]:
        """
        Filter tweets by date range (client-side filtering).

        Args:
            tweets: List of tweet objects with 'created_at' field
            since: Since date/time (relative or absolute)
            until: Until date/time (relative or absolute)

        Returns:
            Filtered list of tweets
        """
        if not since and not until:
            return tweets

        since_dt = APIClient.parse_relative_date(since) if since else datetime.min
        until_dt = APIClient.parse_relative_date(until) if until else datetime.max

        filtered = []
        for tweet in tweets:
            created_at_str = tweet.get("created_at")
            if not created_at_str:
                continue

            try:
                # Parse Twitter date format
                tweet_dt = datetime.fromisoformat(created_at_str.replace('Z', '+00:00'))
                # Remove timezone info for comparison
                tweet_dt = tweet_dt.replace(tzinfo=None)

                if since_dt <= tweet_dt <= until_dt:
                    filtered.append(tweet)
            except:
                # If date parsing fails, include the tweet
                filtered.append(tweet)

        return filtered

    # ============== HTTP Client ==============

    def _check_rate_limit(self, platform: str) -> bool:
        """Check if we're within rate limits for a platform"""
        if platform not in self.rate_limits:
            return True

        last_call, calls_count = self.rate_limits[platform]
        current_time = time.time()

        # Reset counter after 60 seconds
        if current_time - last_call > 60:
            self.rate_limits[platform] = (current_time, 1)
            return True

        # Most APIs allow ~100-300 calls per minute
        if calls_count >= 100:
            print(f"Rate limit reached for {platform}. Waiting...", file=sys.stderr)
            time.sleep(60 - (current_time - last_call))
            self.rate_limits[platform] = (time.time(), 1)
            return True

        # Increment counter
        self.rate_limits[platform] = (last_call, calls_count + 1)
        return True

    def _make_request(self, url: str, headers: Dict = None, params: Dict = None,
                     platform: str = "unknown") -> Optional[Dict]:
        """Make HTTP request with error handling and rate limiting via sc-proxy"""
        self._check_rate_limit(platform)

        try:
            # Configure proxy if available (for routing through sc-proxy)
            proxies = None
            proxy_host = os.environ.get("PROXY_HOST")
            proxy_port = os.environ.get("PROXY_PORT")

            if proxy_host and proxy_port:
                # Handle IPv6 addresses - wrap in brackets
                if ':' in proxy_host and not proxy_host.startswith('['):
                    proxy_host = f"[{proxy_host}]"
                proxy_url = f"http://{proxy_host}:{proxy_port}"
                proxies = {
                    "http": proxy_url,
                    "https": proxy_url
                }

            response = requests.get(url, headers=headers, params=params, proxies=proxies, timeout=10)
            response.raise_for_status()
            return response.json()
        except Exception as e:
            # Check for specific HTTP errors
            if hasattr(e, 'response') and e.response:
                if e.response.status_code == 429:
                    print(f"Rate limited by {platform}. Try again later.", file=sys.stderr)
                elif e.response.status_code == 401:
                    print(f"Authentication failed for {platform}. Check your API credentials.", file=sys.stderr)
                else:
                    print(f"HTTP error for {platform}: {e}", file=sys.stderr)
            else:
                print(f"Request failed for {platform}: {e}", file=sys.stderr)
            return None

    # ============== Twitter/X API Methods (via TwitterAPI.io) ==============

    def get_twitter_user_info(self, username: str) -> Optional[Dict]:
        """
        Fetch detailed user profile information using TwitterAPI.io.

        Args:
            username: Twitter username (without @)

        Returns:
            Dict with user profile data
        """
        if not self.api_key:
            print("TwitterAPI.io API key not configured", file=sys.stderr)
            print("Set TWITTER_API_KEY environment variable", file=sys.stderr)
            return None

        url = "https://api.twitterapi.io/twitter/user/info"
        headers = {
            "X-API-Key": self.api_key
        }
        params = {
            "userName": username.lstrip('@')
        }

        data = self._make_request(url, headers=headers, params=params, platform="twitter")

        if not data or data.get("status") != "success":
            print(f"Failed to fetch user info: {data.get('msg', 'Unknown error')}", file=sys.stderr)
            return None

        user = data.get("data", {})

        return {
            "id": user.get("id"),
            "username": user.get("userName"),
            "name": user.get("name"),
            "description": user.get("description", ""),
            "created_at": user.get("createdAt"),
            "verified": user.get("isBlueVerified", False),
            "followers_count": user.get("followers", 0),
            "following_count": user.get("following", 0),
            "tweet_count": user.get("statusesCount", 0),
            "listed_count": user.get("listedCount", 0),
            "profile_image_url": user.get("profileImage", ""),
            "profile_banner_url": user.get("profileBanner", ""),
            "url": user.get("url", ""),
            "location": user.get("location", ""),
            "unavailable": user.get("unavailable", False)
        }

    def get_twitter_user_timeline(self, username: str, max_results: int = 100, include_replies: bool = False) -> List[Dict]:
        """
        Fetch recent tweets from a user's timeline using TwitterAPI.io.

        Args:
            username: Twitter username (without @)
            max_results: Number of tweets to fetch (fetches in batches of 20)
            include_replies: Include reply tweets

        Returns:
            List of tweet objects with full metadata
        """
        if not self.api_key:
            print("TwitterAPI.io API key not configured", file=sys.stderr)
            return []

        # First, get user info to get user ID
        user_info = self.get_twitter_user_info(username)
        if not user_info:
            return []

        user_id = user_info["id"]
        all_tweets = []
        cursor = ""

        url = "https://api.twitterapi.io/twitter/user/tweet_timeline"
        headers = {
            "X-API-Key": self.api_key
        }

        # Fetch tweets in batches (20 per page)
        while len(all_tweets) < max_results:
            params = {
                "userId": user_id,
                "includeReplies": str(include_replies).lower(),
                "includeParentTweet": "false",
                "cursor": cursor
            }

            data = self._make_request(url, headers=headers, params=params, platform="twitter")

            if not data or data.get("status") != "success":
                break

            # Tweets are in data.tweets, not root.tweets
            tweets = data.get("data", {}).get("tweets", [])
            if not tweets:
                break

            for tweet in tweets:
                all_tweets.append(self._parse_twitterapio_tweet(tweet))

            # Check if there are more pages
            if not data.get("has_next_page"):
                break

            cursor = data.get("next_cursor", "")
            if not cursor:
                break

        return all_tweets[:max_results]

    def search_twitter_tweets(self, query: str, query_type: str = "Latest", max_results: int = 100) -> List[Dict]:
        """
        Search for tweets matching a query using TwitterAPI.io.

        Args:
            query: Search query (e.g., "AI" OR "machine learning" from:username since:2024-01-01)
            query_type: "Latest" or "Top"
            max_results: Number of results to fetch

        Returns:
            List of matching tweets
        """
        if not self.api_key:
            print("TwitterAPI.io API key not configured", file=sys.stderr)
            return []

        all_tweets = []
        cursor = ""

        url = "https://api.twitterapi.io/twitter/tweet/advanced_search"
        headers = {
            "X-API-Key": self.api_key
        }

        while len(all_tweets) < max_results:
            params = {
                "query": query,
                "queryType": query_type,
                "cursor": cursor
            }

            data = self._make_request(url, headers=headers, params=params, platform="twitter")

            if not data:
                break

            # Tweets might be in data.tweets or data.data.tweets depending on endpoint
            tweets = data.get("data", {}).get("tweets", []) or data.get("tweets", [])
            if not tweets:
                break

            for tweet in tweets:
                all_tweets.append(self._parse_twitterapio_tweet(tweet))

            # Check if there are more pages
            if not data.get("has_next_page"):
                break

            cursor = data.get("next_cursor", "")
            if not cursor:
                break

        return all_tweets[:max_results]

    def get_twitter_hashtag_tweets(self, hashtag: str, max_results: int = 100) -> List[Dict]:
        """
        Search for tweets with a specific hashtag.

        Args:
            hashtag: Hashtag to search (with or without #)
            max_results: Number of results

        Returns:
            List of tweets using the hashtag
        """
        # Remove # if present
        hashtag = hashtag.lstrip('#')

        # Search for the hashtag
        query = f"#{hashtag}"
        return self.search_twitter_tweets(query, "Top", max_results)

    def get_user_followers(self, username: str, max_results: int = 200) -> List[Dict]:
        """
        Get followers of a user (200 per page, newest first).

        Args:
            username: Twitter username (without @)
            max_results: Maximum number of followers to fetch

        Returns:
            List of user objects with follower data
        """
        if not self.api_key:
            print("TwitterAPI.io API key not configured", file=sys.stderr)
            return []

        url = "https://api.twitterapi.io/twitter/user/followers"
        headers = {"X-API-Key": self.api_key}

        all_followers = []
        cursor = ""

        while len(all_followers) < max_results:
            params = {
                "userName": username.lstrip('@'),
                "cursor": cursor,
                "pageSize": min(200, max_results - len(all_followers))
            }

            data = self._make_request(url, headers=headers, params=params, platform="twitter")
            if not data or data.get("status") != "success":
                break

            followers = data.get("followers", [])
            if not followers:
                break

            for follower in followers:
                all_followers.append(self._parse_user_object(follower))

            if not data.get("has_next_page"):
                break
            cursor = data.get("next_cursor", "")
            if not cursor:
                break

        return all_followers[:max_results]

    def get_user_followings(self, username: str, max_results: int = 200) -> List[Dict]:
        """
        Get accounts that a user follows.

        Args:
            username: Twitter username (without @)
            max_results: Maximum number to fetch

        Returns:
            List of user objects
        """
        if not self.api_key:
            print("TwitterAPI.io API key not configured", file=sys.stderr)
            return []

        url = "https://api.twitterapi.io/twitter/user/followings"
        headers = {"X-API-Key": self.api_key}

        all_followings = []
        cursor = ""

        while len(all_followings) < max_results:
            params = {
                "userName": username.lstrip('@'),
                "cursor": cursor,
                "pageSize": min(200, max_results - len(all_followings))
            }

            data = self._make_request(url, headers=headers, params=params, platform="twitter")
            if not data or data.get("status") != "success":
                break

            followings = data.get("followings", [])
            if not followings:
                break

            for following in followings:
                all_followings.append(self._parse_user_object(following))

            if not data.get("has_next_page"):
                break
            cursor = data.get("next_cursor", "")
            if not cursor:
                break

        return all_followings[:max_results]

    def get_tweet_retweeters(self, tweet_id: str, max_results: int = 100) -> List[Dict]:
        """
        Get users who retweeted a tweet.

        Args:
            tweet_id: Tweet ID
            max_results: Maximum number of users to fetch

        Returns:
            List of user objects with follower counts
        """
        if not self.api_key:
            print("TwitterAPI.io API key not configured", file=sys.stderr)
            return []

        url = "https://api.twitterapi.io/twitter/tweet/retweeters"
        headers = {"X-API-Key": self.api_key}

        all_retweeters = []
        cursor = ""

        while len(all_retweeters) < max_results:
            params = {
                "tweetId": tweet_id,
                "cursor": cursor
            }

            data = self._make_request(url, headers=headers, params=params, platform="twitter")
            if not data:
                break

            users = data.get("users", [])
            if not users:
                break

            for user in users:
                all_retweeters.append(self._parse_user_object(user))

            if not data.get("has_next_page"):
                break
            cursor = data.get("next_cursor", "")
            if not cursor:
                break

        return all_retweeters[:max_results]

    def get_tweet_replies(self, tweet_id: str, max_results: int = 100) -> List[Dict]:
        """
        Get replies to a tweet.

        Args:
            tweet_id: Tweet ID
            max_results: Maximum number of replies to fetch

        Returns:
            List of tweet objects (replies) with author data including follower counts
        """
        if not self.api_key:
            print("TwitterAPI.io API key not configured", file=sys.stderr)
            return []

        url = "https://api.twitterapi.io/twitter/tweet/replies"
        headers = {"X-API-Key": self.api_key}

        all_replies = []
        cursor = ""

        while len(all_replies) < max_results:
            params = {
                "tweetId": tweet_id,
                "cursor": cursor
            }

            data = self._make_request(url, headers=headers, params=params, platform="twitter")
            if not data or data.get("status") != "success":
                break

            # API returns replies in "tweets" key, not "replies"
            replies = data.get("tweets", []) or data.get("replies", [])
            if not replies:
                break

            for reply in replies:
                all_replies.append(self._parse_twitterapio_tweet(reply))

            if not data.get("has_next_page"):
                break
            cursor = data.get("next_cursor", "")
            if not cursor:
                break

        return all_replies[:max_results]

    def get_tweet_thread_context(self, tweet_id: str, max_results: int = 100) -> List[Dict]:
        """
        Get the full thread/conversation context for a tweet.

        Args:
            tweet_id: Tweet ID (can be reply or original tweet)
            max_results: Maximum tweets in thread to fetch

        Returns:
            List of tweets in the conversation thread
        """
        if not self.api_key:
            print("TwitterAPI.io API key not configured", file=sys.stderr)
            return []

        url = "https://api.twitterapi.io/twitter/tweet/thread_context"
        headers = {"X-API-Key": self.api_key}

        all_tweets = []
        cursor = ""

        while len(all_tweets) < max_results:
            params = {
                "tweetId": tweet_id,
                "cursor": cursor
            }

            data = self._make_request(url, headers=headers, params=params, platform="twitter")
            if not data or data.get("status") != "success":
                break

            # API returns thread tweets in "tweets" key, not "replies"
            thread_tweets = data.get("tweets", []) or data.get("replies", [])
            if not thread_tweets:
                break

            for tweet in thread_tweets:
                all_tweets.append(self._parse_twitterapio_tweet(tweet))

            if not data.get("has_next_page"):
                break
            cursor = data.get("next_cursor", "")
            if not cursor:
                break

        return all_tweets[:max_results]

    def batch_get_user_by_userids(self, user_ids: List[str]) -> List[Dict]:
        """
        Batch fetch user information by user IDs (efficient for multiple users).

        Args:
            user_ids: List of Twitter user IDs

        Returns:
            List of user objects
        """
        if not self.api_key:
            print("TwitterAPI.io API key not configured", file=sys.stderr)
            return []

        url = "https://api.twitterapi.io/twitter/user/batch_info_by_ids"
        headers = {"X-API-Key": self.api_key}

        # API accepts comma-separated IDs
        params = {
            "userIds": ",".join(user_ids)
        }

        data = self._make_request(url, headers=headers, params=params, platform="twitter")
        if not data or data.get("status") != "success":
            return []

        users = data.get("users", [])
        return [self._parse_user_object(user) for user in users]

    def check_follow_relationship(self, source_username: str, target_username: str) -> bool:
        """
        Check if source_username follows target_username.

        Args:
            source_username: Username to check (does this user follow target?)
            target_username: Target username

        Returns:
            True if source follows target, False otherwise
        """
        if not self.api_key:
            print("TwitterAPI.io API key not configured", file=sys.stderr)
            return False

        url = "https://api.twitterapi.io/twitter/user/follow_relationship"
        headers = {"X-API-Key": self.api_key}

        params = {
            "sourceUserName": source_username.lstrip('@'),
            "targetUserName": target_username.lstrip('@')
        }

        data = self._make_request(url, headers=headers, params=params, platform="twitter")
        if not data or data.get("status") != "success":
            return False

        return data.get("data", {}).get("following", False)

    def get_user_verified_followers(self, user_id: str, max_results: int = 100) -> List[Dict]:
        """
        Get verified followers of a user (costs $0.3 per 1,000).

        Args:
            user_id: Twitter user ID (not username)
            max_results: Maximum verified followers to fetch

        Returns:
            List of verified follower user objects
        """
        if not self.api_key:
            print("TwitterAPI.io API key not configured", file=sys.stderr)
            return []

        url = "https://api.twitterapi.io/twitter/user/verifiedFollowers"
        headers = {"X-API-Key": self.api_key}

        all_followers = []
        cursor = ""

        while len(all_followers) < max_results:
            params = {
                "user_id": user_id,
                "cursor": cursor
            }

            data = self._make_request(url, headers=headers, params=params, platform="twitter")
            if not data or data.get("status") != "success":
                break

            followers = data.get("followers", [])
            if not followers:
                break

            for follower in followers:
                all_followers.append(self._parse_user_object(follower))

            if not data.get("has_next_page"):
                break
            cursor = data.get("next_cursor", "")
            if not cursor:
                break

        return all_followers[:max_results]

    def get_trends(self, woeid: int = 1) -> List[Dict]:
        """
        Get trending topics by location (default: worldwide).

        Args:
            woeid: Where On Earth ID (1=worldwide, 2418046=Washington DC, etc.)
                   Full list: https://gist.github.com/tedyblood/5bb5a9f78314cc1f478b3dd7cde790b9

        Returns:
            List of trending topics with rank and meta description
        """
        if not self.api_key:
            print("TwitterAPI.io API key not configured", file=sys.stderr)
            return []

        url = "https://api.twitterapi.io/twitter/trends"
        headers = {"X-API-Key": self.api_key}

        params = {
            "woeid": woeid,
            "num": 30  # Default to 30 trends
        }

        data = self._make_request(url, headers=headers, params=params, platform="twitter")
        if not data or data.get("status") != "success":
            return []

        trends = data.get("trends", [])
        return [{
            "name": trend.get("name"),
            "query": trend.get("target", {}).get("query"),
            "rank": trend.get("rank"),
            "meta_description": trend.get("meta_description", "")
        } for trend in trends]

    def get_space_detail(self, space_id: str) -> Optional[Dict]:
        """
        Get details about a Twitter Space (live audio event).

        Args:
            space_id: Twitter Space ID

        Returns:
            Dict with Space information (metadata, participants, stats)
        """
        if not self.api_key:
            print("TwitterAPI.io API key not configured", file=sys.stderr)
            return None

        url = "https://api.twitterapi.io/twitter/spaces/detail"
        headers = {"X-API-Key": self.api_key}

        params = {"space_id": space_id}

        data = self._make_request(url, headers=headers, params=params, platform="twitter")
        if not data or data.get("status") != "success":
            return None

        space_data = data.get("data", {})
        return {
            "id": space_data.get("id"),
            "title": space_data.get("title"),
            "state": space_data.get("state"),  # NotStarted/Live/Ended
            "created_at": space_data.get("created_at"),
            "scheduled_start": space_data.get("scheduled_start"),
            "live_listener_count": space_data.get("live_listener_count", 0),
            "total_replay_watched": space_data.get("total_replay_watched", 0),
            "creator": space_data.get("creator", {}),
            "participants": space_data.get("participants", {})
        }

    def _parse_user_object(self, user: Dict) -> Dict:
        """Parse TwitterAPI.io user object into standardized format"""
        return {
            "id": user.get("id"),
            "username": user.get("userName"),
            "name": user.get("name"),
            "description": user.get("description", ""),
            "created_at": user.get("createdAt"),
            "verified": user.get("isBlueVerified", False),
            "verified_type": user.get("verifiedType"),
            "followers": user.get("followers", 0),
            "following": user.get("following", 0),
            "tweet_count": user.get("statusesCount", 0),
            "media_count": user.get("mediaCount", 0),
            "favourites_count": user.get("favouritesCount", 0),
            "profile_image_url": user.get("profilePicture", ""),
            "profile_banner_url": user.get("coverPicture", ""),
            "location": user.get("location", ""),
            "url": user.get("url", ""),
            "can_dm": user.get("canDm", False),
            "unavailable": user.get("unavailable", False)
        }

    def _parse_twitterapio_tweet(self, tweet: Dict) -> Dict:
        """Parse TwitterAPI.io tweet object into standardized format"""
        # Extract author info
        author = tweet.get("author", {})

        # Detect tweet type
        is_reply = tweet.get("inReplyToStatusId") is not None
        is_retweet = tweet.get("type") == "retweet"
        is_quote = tweet.get("quotedTweet") is not None

        # Extract entities
        entities = tweet.get("entities", {})
        hashtags = [tag.get("text", "") for tag in entities.get("hashtags", [])]
        mentions = [mention.get("screenName", "") for mention in entities.get("userMentions", [])]
        urls = [url.get("expandedUrl", "") for url in entities.get("urls", [])]

        return {
            "id": tweet.get("id"),
            "conversation_id": tweet.get("conversationId"),
            "text": tweet.get("text", ""),
            "created_at": tweet.get("createdAt"),
            "likes": tweet.get("likeCount", 0),
            "retweets": tweet.get("retweetCount", 0),
            "replies": tweet.get("replyCount", 0),
            "quotes": tweet.get("quoteCount", 0),
            "views": tweet.get("viewCount", 0),
            "bookmarks": tweet.get("bookmarkCount", 0),
            "is_reply": is_reply,
            "is_retweet": is_retweet,
            "is_quote": is_quote,
            "hashtags": hashtags,
            "mentions": mentions,
            "urls": urls,
            "url": tweet.get("url", f"https://twitter.com/i/web/status/{tweet.get('id')}"),
            "author": {
                "id": author.get("id"),
                "username": author.get("userName"),
                "name": author.get("name"),
                "followers": author.get("followers", 0),
                "verified": author.get("isBlueVerified", False)
            }
        }


def main():
    """Test the Twitter API client"""
    client = APIClient()

    print("Testing Twitter API Client...")
    print("\nNote: Requires TWITTER_API_KEY environment variable")

    if client.api_key:
        print("\nFetching info for @elonmusk...")
        user_info = client.get_twitter_user_info("elonmusk")
        if user_info:
            print(f"  Name: {user_info['name']}")
            print(f"  Followers: {user_info['followers_count']:,}")
            print(f"  Tweets: {user_info['tweet_count']:,}")
    else:
        print("Twitter API key not configured. Set TWITTER_API_KEY environment variable")

    print("\nAPI client test complete.")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
ASCII Art Formatter for Creator Insights
Beautiful terminal output with box drawing, bars, and emojis.
"""

def create_box(title, width=60):
    """Create a fancy box with title"""
    top = f"╔{'═' * (width - 2)}╗"
    title_line = f"║ {title.center(width - 4)} ║"
    separator = f"╠{'═' * (width - 2)}╣"
    bottom = f"╚{'═' * (width - 2)}╝"
    return top, title_line, separator, bottom


def create_header(text, width=60):
    """Create a header with double lines"""
    border = "═" * width
    centered = text.center(width)
    return f"\n{border}\n{centered}\n{border}"


def create_section_header(text, width=60):
    """Create a section header with emoji"""
    line = "─" * width
    return f"\n{text}\n{line}"


def create_progress_bar(value, max_value, width=20, filled_char="█", empty_char="░"):
    """Create a visual progress bar

    Args:
        value: Current value
        max_value: Maximum value
        width: Width of the bar in characters
        filled_char: Character for filled portion
        empty_char: Character for empty portion

    Returns:
        String representation of progress bar
    """
    if max_value == 0:
        percentage = 0
    else:
        percentage = min(100, (value / max_value) * 100)

    filled_length = int(width * percentage / 100)
    bar = filled_char * filled_length + empty_char * (width - filled_length)
    return f"{bar} {percentage:.1f}%"


def create_metric_bar(label, value, max_value, width=40, show_value=True):
    """Create a labeled metric bar"""
    bar_width = width - len(label) - 12  # Space for label and value
    bar = create_progress_bar(value, max_value, bar_width)

    if show_value:
        value_str = format_number(value)
        return f"  {label:<20} {bar}  {value_str:>10}"
    else:
        return f"  {label:<20} {bar}"


def format_number(num):
    """Format number with K/M suffix"""
    if num >= 1_000_000:
        return f"{num / 1_000_000:.1f}M"
    elif num >= 1_000:
        return f"{num / 1_000:.1f}K"
    else:
        return f"{num:.0f}"


def create_sparkline(data, width=20):
    """Create a sparkline (mini line chart) from data

    Args:
        data: List of numeric values
        width: Width of sparkline in characters

    Returns:
        String representation of sparkline
    """
    if not data or len(data) == 0:
        return "─" * width

    # Sparkline characters from low to high
    chars = ['▁', '▂', '▃', '▄', '▅', '▆', '▇', '█']

    min_val = min(data)
    max_val = max(data)

    if max_val == min_val:
        return chars[4] * min(len(data), width)

    # Normalize and convert to sparkline
    normalized = [(x - min_val) / (max_val - min_val) for x in data]
    sparkline = ''.join([chars[min(int(x * len(chars)), len(chars) - 1)] for x in normalized])

    # Truncate or pad to width
    if len(sparkline) > width:
        return sparkline[:width]
    else:
        return sparkline


def create_stat_card(label, value, change=None, width=30):
    """Create a stat card with optional change indicator

    Args:
        label: Metric label
        value: Current value
        change: Optional change value (positive/negative)
        width: Width of card

    Returns:
        Multi-line stat card
    """
    top = f"┌{'─' * (width - 2)}┐"
    label_line = f"│ {label:<{width - 4}} │"
    value_line = f"│ {str(value):<{width - 4}} │"

    if change is not None:
        if change > 0:
            change_str = f"↑ +{change:.1f}%"
            emoji = "📈"
        elif change < 0:
            change_str = f"↓ {change:.1f}%"
            emoji = "📉"
        else:
            change_str = "→ 0.0%"
            emoji = "➡️"

        change_line = f"│ {emoji} {change_str:<{width - 7}} │"
    else:
        change_line = f"│{' ' * (width - 2)}│"

    bottom = f"└{'─' * (width - 2)}┘"

    return f"{top}\n{label_line}\n{value_line}\n{change_line}\n{bottom}"


def create_table_row(columns, widths, separator="│"):
    """Create a table row with aligned columns

    Args:
        columns: List of column values
        widths: List of column widths
        separator: Column separator character

    Returns:
        Formatted table row
    """
    formatted_cols = []
    for col, width in zip(columns, widths):
        col_str = str(col)
        if len(col_str) > width:
            col_str = col_str[:width - 3] + "..."
        formatted_cols.append(col_str.ljust(width))

    return f"{separator} {' │ '.join(formatted_cols)} {separator}"


def create_table_separator(widths, style="middle"):
    """Create table separator line

    Args:
        widths: List of column widths
        style: 'top', 'middle', or 'bottom'

    Returns:
        Separator line
    """
    if style == "top":
        left, mid, right, line = "┌", "┬", "┐", "─"
    elif style == "bottom":
        left, mid, right, line = "└", "┴", "┘", "─"
    else:  # middle
        left, mid, right, line = "├", "┼", "┤", "─"

    segments = [line * (w + 2) for w in widths]
    return f"{left}{mid.join(segments)}{right}"


def create_ranking_list(items, title="Rankings", width=60, show_bars=True):
    """Create a visual ranking list

    Args:
        items: List of tuples (rank, label, value)
        title: List title
        width: Width of display
        show_bars: Whether to show value bars

    Returns:
        Formatted ranking list
    """
    output = []
    output.append(create_section_header(f"🏆 {title}", width))

    if not items:
        output.append("  No data available")
        return "\n".join(output)

    max_value = max([item[2] for item in items]) if items else 1

    for rank, label, value in items:
        # Rank emoji
        if rank == 1:
            rank_emoji = "🥇"
        elif rank == 2:
            rank_emoji = "🥈"
        elif rank == 3:
            rank_emoji = "🥉"
        else:
            rank_emoji = f"{rank}."

        # Format value
        value_str = format_number(value)

        if show_bars:
            bar_width = width - len(str(rank_emoji)) - len(label) - len(value_str) - 8
            bar = create_progress_bar(value, max_value, bar_width)
            line = f"  {rank_emoji} {label:<25} {bar} {value_str:>8}"
        else:
            line = f"  {rank_emoji} {label:<40} {value_str:>12}"

        output.append(line)

    return "\n".join(output)


def create_comparison_bars(data, width=60):
    """Create side-by-side comparison bars

    Args:
        data: List of tuples (label, value1, value2, label1, label2)
        width: Width of display

    Returns:
        Formatted comparison
    """
    output = []

    for label, val1, val2, label1, label2 in data:
        total = val1 + val2
        if total == 0:
            continue

        bar_width = width - len(label) - 4
        val1_width = int((val1 / total) * bar_width)
        val2_width = bar_width - val1_width

        bar1 = "█" * val1_width
        bar2 = "░" * val2_width

        output.append(f"  {label}")
        output.append(f"    {label1}: {bar1}{bar2} {val1:.1f}")
        output.append(f"    {label2}: {bar2}{bar1} {val2:.1f}")
        output.append("")

    return "\n".join(output)


def create_emoji_indicator(value, thresholds):
    """Create emoji-based indicator

    Args:
        value: Numeric value
        thresholds: List of tuples (threshold, emoji)

    Returns:
        Appropriate emoji
    """
    for threshold, emoji in sorted(thresholds, reverse=True):
        if value >= threshold:
            return emoji
    return thresholds[-1][1]  # Return lowest threshold emoji


def wrap_in_box(content, title=None, width=60):
    """Wrap content in a fancy box

    Args:
        content: Text content (can be multi-line)
        title: Optional title
        width: Box width

    Returns:
        Boxed content
    """
    lines = content.split('\n')
    output = []

    # Top border
    if title:
        title_text = f" {title} "
        padding = (width - len(title_text) - 2) // 2
        top = f"╔{'═' * padding}{title_text}{'═' * (width - padding - len(title_text) - 2)}╗"
    else:
        top = f"╔{'═' * (width - 2)}╗"

    output.append(top)

    # Content lines
    for line in lines:
        # Truncate or pad line
        if len(line) > width - 4:
            line = line[:width - 7] + "..."
        padded = line.ljust(width - 4)
        output.append(f"║ {padded} ║")

    # Bottom border
    bottom = f"╚{'═' * (width - 2)}╝"
    output.append(bottom)

    return "\n".join(output)


def create_info_panel(icon, title, content, width=60):
    """Create an info panel with icon

    Args:
        icon: Emoji icon
        title: Panel title
        content: List of content lines
        width: Panel width

    Returns:
        Formatted panel
    """
    output = []
    header = f"{icon} {title}"
    output.append(f"\n┌{'─' * (width - 2)}┐")
    output.append(f"│ {header:<{width - 4}} │")
    output.append(f"├{'─' * (width - 2)}┤")

    for line in content:
        if len(line) > width - 4:
            line = line[:width - 7] + "..."
        output.append(f"│ {line:<{width - 4}} │")

    output.append(f"└{'─' * (width - 2)}┘")

    return "\n".join(output)


# ANSI color codes (optional, works on most terminals)
class Colors:
    RESET = "\033[0m"
    BOLD = "\033[1m"
    DIM = "\033[2m"

    # Regular colors
    BLACK = "\033[30m"
    RED = "\033[31m"
    GREEN = "\033[32m"
    YELLOW = "\033[33m"
    BLUE = "\033[34m"
    MAGENTA = "\033[35m"
    CYAN = "\033[36m"
    WHITE = "\033[37m"

    # Bright colors
    BRIGHT_BLACK = "\033[90m"
    BRIGHT_RED = "\033[91m"
    BRIGHT_GREEN = "\033[92m"
    BRIGHT_YELLOW = "\033[93m"
    BRIGHT_BLUE = "\033[94m"
    BRIGHT_MAGENTA = "\033[95m"
    BRIGHT_CYAN = "\033[96m"
    BRIGHT_WHITE = "\033[97m"


def colorize(text, color):
    """Add ANSI color to text

    Args:
        text: Text to colorize
        color: Color from Colors class

    Returns:
        Colorized text
    """
    return f"{color}{text}{Colors.RESET}"