Skip to content

nexscope-ai/eCommerce-Skills / brand-monitoring

brand-monitoring

Verified

Brand monitoring tool for tracking mentions across social media platforms. Monitor Reddit, Google News, YouTube, and DuckDuckGo for brand mentions. Includes sentiment analysis, trend tracking, crisis detection, and competitor comparison. No API key required for basic monitoring.

FileKindSize
SKILL.mdskill md3.9 KB
scripts/monitor.pyscript22.4 KB
scripts/scrapers.pyscript7.9 KB

scripts/scrapers.py

View on GitHub
#!/usr/bin/env python3
"""
Brand Monitoring - Data Scrapers (Lite)
Brand Monitoring - DataCollect (Free version)

Datasource:
- Reddit (PublicSearch/Pushshift)
- Google News (RSS)
- YouTube (PublicSearch)
- DuckDuckGo (Search)

Note: Please comply withPlatformUseTerms

Version: 1.0.0
"""

import json
import re
import urllib.request
import urllib.parse
from typing import List, Dict, Optional
from dataclasses import dataclass
from datetime import datetime
import time
import sys


@dataclass
class SearchResult:
    """SearchResult"""
    title: str
    content: str
    url: str
    source: str
    date: Optional[str] = None
    author: Optional[str] = None
    engagement: int = 0


class RedditScraper:
    """Reddit Search (UsePublic JSON Interface)"""
    
    BASE_URL = "https://www.reddit.com"
    
    def search(self, query: str, limit: int = 25, sort: str = "relevance") -> List[SearchResult]:
        """Search Reddit"""
        results = []
        
        try:
            # Use Reddit Public JSON Interface
            encoded_query = urllib.parse.quote(query)
            url = f"{self.BASE_URL}/search.json?q={encoded_query}&limit={limit}&sort={sort}"
            
            req = urllib.request.Request(url, headers={
                "User-Agent": "Mozilla/5.0 (compatible; BrandMonitor/1.0)"
            })
            
            print(f"[Reddit] Searching: {query}")
            
            # Note:ActualUseNeedProcess rate limiting
            # with urllib.request.urlopen(req, timeout=10) as response:
            #     data = json.loads(response.read().decode())
            #     for post in data.get("data", {}).get("children", []):
            #         post_data = post.get("data", {})
            #         results.append(SearchResult(
            #             title=post_data.get("title", ""),
            #             content=post_data.get("selftext", "")[:500],
            #             url=f"https://reddit.com{post_data.get('permalink', '')}",
            #             source="reddit",
            #             author=post_data.get("author", ""),
            #             engagement=post_data.get("score", 0) + post_data.get("num_comments", 0),
            #         ))
            
            print(f"[Reddit] Note: Enable actual API call in production")
            
        except Exception as e:
            print(f"[Reddit] Error: {e}")
        
        return results


class GoogleNewsScraper:
    """Google News Search (Use RSS)"""
    
    RSS_URL = "https://news.google.com/rss/search"
    
    def search(self, query: str, limit: int = 20) -> List[SearchResult]:
        """Search Google News"""
        results = []
        
        try:
            encoded_query = urllib.parse.quote(query)
            url = f"{self.RSS_URL}?q={encoded_query}&hl=en-US&gl=US&ceid=US:en"
            
            req = urllib.request.Request(url, headers={
                "User-Agent": "Mozilla/5.0 (compatible; BrandMonitor/1.0)"
            })
            
            print(f"[Google News] Searching: {query}")
            
            # Note:Actual implementation requiresParse RSS XML
            # with urllib.request.urlopen(req, timeout=10) as response:
            #     # Parse RSS XML
            #     pass
            
            print(f"[Google News] Note: Enable actual RSS parsing in production")
            
        except Exception as e:
            print(f"[Google News] Error: {e}")
        
        return results


class DuckDuckGoScraper:
    """DuckDuckGo Search (Free,no API key)"""
    
    # DuckDuckGo Instant Answer API
    API_URL = "https://api.duckduckgo.com/"
    
    def search(self, query: str) -> List[SearchResult]:
        """Search DuckDuckGo"""
        results = []
        
        try:
            params = urllib.parse.urlencode({
                "q": query,
                "format": "json",
                "no_html": 1,
            })
            url = f"{self.API_URL}?{params}"
            
            req = urllib.request.Request(url, headers={
                "User-Agent": "Mozilla/5.0 (compatible; BrandMonitor/1.0)"
            })
            
            print(f"[DuckDuckGo] Searching: {query}")
            
            # with urllib.request.urlopen(req, timeout=10) as response:
            #     data = json.loads(response.read().decode())
            #     # ParseResult
            
            print(f"[DuckDuckGo] Note: Enable actual API call in production")
            
        except Exception as e:
            print(f"[DuckDuckGo] Error: {e}")
        
        return results


class YouTubeScraper:
    """YouTube Search (no API key PublicSearch)"""
    
    SEARCH_URL = "https://www.youtube.com/results"
    
    def search(self, query: str, limit: int = 20) -> List[SearchResult]:
        """Search YouTube (NeedParse HTML  or Use API)"""
        results = []
        
        print(f"[YouTube] Searching: {query}")
        print(f"[YouTube] Note: Use YouTube Data API v3 for production")
        
        return results


class TwitterScraper:
    """Twitter/X Search (Need API v2)"""
    
    def search(self, query: str, limit: int = 100) -> List[SearchResult]:
        """Search Twitter (Need Bearer Token)"""
        results = []
        
        print(f"[Twitter] Searching: {query}")
        print(f"[Twitter] Note: Requires Twitter API v2 Bearer Token for production")
        
        return results


# ============================================================
# UnifiedSearchInterface
# ============================================================

class BrandSearcher:
    """BrandSearchUnified interface"""
    
    def __init__(self):
        self.reddit = RedditScraper()
        self.google_news = GoogleNewsScraper()
        self.duckduckgo = DuckDuckGoScraper()
        self.youtube = YouTubeScraper()
        self.twitter = TwitterScraper()
    
    def search_all(
        self,
        brand_name: str,
        platforms: List[str] = None,
        limit_per_platform: int = 20
    ) -> Dict[str, List[SearchResult]]:
        """Searchplace has Platform"""
        
        if platforms is None:
            platforms = ["reddit", "google_news", "duckduckgo"]
        
        results = {}
        
        for platform in platforms:
            time.sleep(1)  # Avoid rate limiting
            
            if platform == "reddit":
                results["reddit"] = self.reddit.search(brand_name, limit_per_platform)
            elif platform == "google_news":
                results["google_news"] = self.google_news.search(brand_name, limit_per_platform)
            elif platform == "duckduckgo":
                results["duckduckgo"] = self.duckduckgo.search(brand_name)
            elif platform == "youtube":
                results["youtube"] = self.youtube.search(brand_name, limit_per_platform)
            elif platform == "twitter":
                results["twitter"] = self.twitter.search(brand_name, limit_per_platform)
        
        return results
    
    def get_total_results(self, results: Dict[str, List[SearchResult]]) -> List[SearchResult]:
        """Merge allResult"""
        all_results = []
        for platform_results in results.values():
            all_results.extend(platform_results)
        return all_results


# ============================================================
# CLI
# ============================================================

def main():
    brand = sys.argv[1] if len(sys.argv) > 1 else "TechBrand"
    
    searcher = BrandSearcher()
    
    print(f"\n🔍 Searching for brand: {brand}\n")
    print("=" * 50)
    
    results = searcher.search_all(brand)
    
    total = sum(len(r) for r in results.values())
    print(f"\n📊 Total results: {total}")
    
    for platform, platform_results in results.items():
        print(f"  - {platform}: {len(platform_results)}")
    
    print("\n⚠️ Note: Enable actual API calls in scrapers.py for production use")
    print("   Current implementation is in demo mode.")


if __name__ == "__main__":
    main()
receiving-code-reviewobra/superpowersUse when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementationStars: 323kUpdated Claude CodeCodexVerifiedInstall
requesting-code-reviewobra/superpowersUse when completing tasks, implementing major features, or before merging to verify work meets requirementsStars: 323kUpdated Claude CodeCodexVerifiedInstall
using-git-worktreesobra/superpowersUse when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallbackStars: 323kUpdated Claude CodeCodexVerifiedInstall
verification-before-completionobra/superpowersUse when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions alwaysStars: 323kUpdated Claude CodeCodexVerifiedInstall