Upload 03GetTweetsFor800Users

02CommonConcern20to50/2.py

@@ -0,0 +1,114 @@
+import sqlite3
+import pandas as pd
+import os
+from datetime import datetime
+import json
+
+def process_following_data(source_db_path, target_db_path, min_followers=20, max_followers=50):
+    """
+    处理关注者数据，筛选出符合条件的用户并保存到新数据库
+    """
+    if not os.path.exists(source_db_path):
+        raise FileNotFoundError(f"找不到数据库文件: {source_db_path}")
+    
+    conn = sqlite3.connect(source_db_path)
+    
+    print("正在读取关注关系数据...")
+    df_relationships = pd.read_sql_query("""
+        SELECT user_id, following_of
+        FROM following_relationships
+    """, conn)
+    
+    print("正在统计关注者数量...")
+    grouped = (
+        df_relationships
+        .groupby('user_id')['following_of']
+        .agg(lambda x: list(set(x)))
+        .reset_index()
+    )
+    grouped['follower_count'] = grouped['following_of'].apply(len)
+    
+    filtered = grouped[
+        (grouped['follower_count'] >= min_followers) & 
+        (grouped['follower_count'] <= max_followers)
+    ]
+    
+    print("正在获取用户详细信息...")
+    target_users = tuple(filtered['user_id'].tolist())
+    
+    if not target_users:
+        print("没有找到符合条件的用户")
+        conn.close()
+        return 0
+    
+    # 将列表转换为字符串
+    filtered['following_of'] = filtered['following_of'].apply(json.dumps)
+    
+    users_df = pd.read_sql_query("""
+        SELECT *
+        FROM users
+        WHERE user_id IN ({})
+    """.format(','.join(['?' for _ in target_users])), conn, params=target_users)
+    
+    # 合并数据，只保留需要的列
+    result_df = pd.merge(
+        users_df,
+        filtered[['user_id', 'follower_count']],
+        on='user_id',
+        how='inner'
+    )
+    
+    print(f"正在保存符合条件的 {len(result_df)} 个用户信息到新数据库...")
+    
+    # 保存到新数据库
+    target_conn = sqlite3.connect(target_db_path)
+    
+    # 确保删除following_of列（如果存在），因为我们会在单独的表中存储它
+    if 'following_of' in result_df.columns:
+        result_df = result_df.drop('following_of', axis=1)
+    
+    # 创建主表
+    result_df.to_sql('users', target_conn, index=False, if_exists='replace')
+    
+    # 创建索引
+    target_conn.execute("CREATE INDEX IF NOT EXISTS idx_user_id ON users(user_id)")
+    target_conn.execute("CREATE INDEX IF NOT EXISTS idx_followers_count ON users(followers_count)")
+    
+    # 创建并填充关注者表
+    target_conn.execute("""
+        CREATE TABLE IF NOT EXISTS user_followers (
+            user_id TEXT PRIMARY KEY,
+            followers TEXT,
+            follower_count INTEGER,
+            FOREIGN KEY(user_id) REFERENCES users(user_id)
+        )
+    """)
+    
+    # 准备关注者数据
+    followers_data = filtered[['user_id', 'following_of', 'follower_count']]
+    followers_data.to_sql('user_followers', target_conn, index=False, if_exists='replace')
+    
+    # 打印预览
+    print("\n符合条件的用户数据预览：")
+    preview_df = result_df[['user_id', 'name', 'followers_count', 'friends_count']].head()
+    print(preview_df)
+    
+    conn.close()
+    target_conn.close()
+    
+    return len(result_df)
+
+if __name__ == "__main__":
+    # 设置数据库路径
+    source_db = "following_expanded.db"
+    target_db = f"filtered_users_{datetime.now().strftime('%Y%m%d_%H%M%S')}.db"
+    
+    try:
+        result_count = process_following_data(source_db, target_db)
+        print(f"\n处理完成！已将 {result_count} 个用户的信息保存到 {target_db}")
+    except Exception as e:
+        print(f"处理过程中出现错误: {str(e)}")
+        # 打印详细的错误跟踪信息
+        import traceback
+        print("\n详细错误信息:")
+        print(traceback.format_exc())

02CommonConcern20to50/requirements.txt

@@ -0,0 +1,4 @@
+requests>=2.25.0
+urllib3>=2.0.0
+typing>=3.7.4
+sqlite3-api>=2.0.0

02CommonConcern20to50/result/filtered_users.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:297b29029aaf2b55c5018c0e115d0e7677bf0bc38ebe531248be56af0e344f34
+size 3432448

03GetTweetsFor800Users/3.py

@@ -0,0 +1,516 @@
+import aiohttp
+import asyncio
+import json
+import logging
+import sqlite3
+import pandas as pd
+from datetime import datetime, timedelta
+from email.utils import parsedate_to_datetime
+from typing import List, Dict, Set, Optional, Tuple
+from pathlib import Path
+
+class QuotaLowException(Exception):
+    pass
+
+class ArticleCrawler:
+    def __init__(self, api_key: str, source_db: str, target_user_count: int = 800, output_db: str = "tweets.db"):
+        self.api_key = api_key
+        self.base_url = "https://api.tweetscout.io/v2"
+        self.source_db = source_db
+        self.target_user_count = target_user_count
+        self.db_path = output_db
+        self.headers = {
+            "ApiKey": api_key,
+            "Accept": "application/json"
+        }
+        self.processed_users_file = "processed_users.json"
+        self.no_tweets_users_file = "no_tweets_users.json"
+        self.processed_users: Set[str] = self._load_processed_users()
+        self.no_tweets_users: Set[str] = self._load_no_tweets_users()
+        self.api_call_count = 0
+        self.warning_threshold = 5500 # 提高阈值到5000次调用
+        self.last_save_time = datetime.now()
+        self.save_interval = timedelta(minutes=5)  # 每5分钟保存一次
+        self._setup_logging()
+        self._init_database()
+
+    def _load_processed_users(self) -> Set[str]:
+        if Path(self.processed_users_file).exists():
+            try:
+                with open(self.processed_users_file, 'r') as f:
+                    return set(json.load(f))
+            except Exception as e:
+                logging.error(f"Error loading processed users: {e}")
+                return set()
+        return set()
+
+    def _load_no_tweets_users(self) -> Set[str]:
+        if Path(self.no_tweets_users_file).exists():
+            try:
+                with open(self.no_tweets_users_file, 'r') as f:
+                    return set(json.load(f))
+            except Exception as e:
+                logging.error(f"Error loading no tweets users: {e}")
+                return set()
+        return set()
+
+    def _save_processed_users(self):
+        try:
+            with open(self.processed_users_file, 'w') as f:
+                json.dump(list(self.processed_users), f)
+        except Exception as e:
+            logging.error(f"Error saving processed users: {e}")
+
+    def _save_no_tweets_users(self):
+        try:
+            with open(self.no_tweets_users_file, 'w') as f:
+                json.dump(list(self.no_tweets_users), f)
+        except Exception as e:
+            logging.error(f"Error saving no tweets users: {e}")
+
+    def _get_next_rotation_time(self):
+        """计算下一次日志切换的时间"""
+        now = datetime.now()
+        if now.hour < 12:
+            # 如果当前时间早于12点，下次切换时间为当天12点
+            next_rotation = now.replace(hour=12, minute=0, second=0, microsecond=0)
+        else:
+            # 如果当前时间晚于12点，下次切换时间为第二天0点
+            next_rotation = (now + timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0)
+        return next_rotation
+
+    def get_progress_stats(self) -> Dict:
+        """获取当前进度统计"""
+        try:
+            if not hasattr(self, 'cursor') or self.cursor is None:
+                return {
+                    'user_count': 0,
+                    'tweet_count': 0,
+                    'start_time': None,
+                    'last_update': None,
+                    'processed_users': len(self.processed_users),
+                    'no_tweets_users': len(self.no_tweets_users)
+                }
+                
+            self.cursor.execute("""
+                SELECT 
+                    COUNT(DISTINCT author_id) as user_count,
+                    COUNT(*) as tweet_count,
+                    MIN(collected_at) as start_time,
+                    MAX(collected_at) as last_update
+                FROM tweets
+            """)
+            stats = dict(zip(['user_count', 'tweet_count', 'start_time', 'last_update'], 
+                            self.cursor.fetchone()))
+            stats['processed_users'] = len(self.processed_users)
+            stats['no_tweets_users'] = len(self.no_tweets_users)
+            return stats
+        except Exception as e:
+            self.logger.error(f"Error getting progress stats: {e}")
+            return {
+                'user_count': 0,
+                'tweet_count': 0,
+                'start_time': None,
+                'last_update': None,
+                'processed_users': len(self.processed_users),
+                'no_tweets_users': len(self.no_tweets_users)
+            }
+
+    def _rotate_log_file(self):
+        """切换到新的日志文件"""
+        # 关闭现有的文件处理器
+        for handler in self.logger.handlers[:]:
+            if isinstance(handler, logging.FileHandler):
+                handler.close()
+                self.logger.removeHandler(handler)
+
+        # 创建新的文件处理器，使用 utf-8 编码
+        new_log_file = f"crawler_{datetime.now().strftime('%Y%m%d_%H%M')}.log"
+        file_handler = logging.FileHandler(new_log_file, encoding='utf-8')
+        file_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+        self.logger.addHandler(file_handler)
+
+        # 计算并设置下次切换时间
+        self.next_log_rotation = self._get_next_rotation_time()
+
+        # 输出进度统计
+        stats = self.get_progress_stats()
+        self.logger.info(f"Rotated to new log file: {new_log_file}")
+        self.logger.info(f"Progress Stats: {json.dumps(stats, default=str)}")
+    def _setup_logging(self):
+        """设置日志系统"""
+        self.logger = logging.getLogger("ArticleCrawler")
+        self.logger.setLevel(logging.INFO)
+
+        # 添加控制台处理器
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+        self.logger.addHandler(console_handler)
+
+        # 设置初始日志文件
+        self.next_log_rotation = self._get_next_rotation_time()
+        self._rotate_log_file()
+
+    def _init_database(self):
+        self.conn = sqlite3.connect(
+            self.db_path, 
+            detect_types=sqlite3.PARSE_DECLTYPES|sqlite3.PARSE_COLNAMES,
+            timeout=30
+        )
+        self.conn.execute("PRAGMA journal_mode=WAL")
+        self.conn.execute("PRAGMA synchronous=NORMAL")
+        self.cursor = self.conn.cursor()
+
+        self.cursor.executescript('''
+            CREATE TABLE IF NOT EXISTS tweets (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                tweet_id TEXT UNIQUE,
+                author_id TEXT,
+                author_name TEXT,
+                full_text TEXT,
+                created_at TIMESTAMP,
+                likes_count INTEGER DEFAULT 0,
+                retweets_count INTEGER DEFAULT 0,
+                replies_count INTEGER DEFAULT 0,
+                views_count INTEGER DEFAULT 0,
+                quote_count INTEGER DEFAULT 0,
+                is_quote_status BOOLEAN DEFAULT 0,
+                conversation_id TEXT,
+                in_reply_to_status_id TEXT,
+                quoted_status TEXT,          -- 引用推文信息，存储为JSON
+                retweeted_status TEXT,       -- 转发推文信息，存储为JSON
+                entities TEXT,               -- 推文中的链接、媒体等实体，存储为JSON
+                author_avatar TEXT,          -- 作者头像URL
+                author_description TEXT,     -- 作者简介
+                author_followers_count INT,  -- 作者粉丝数
+                author_friends_count INT,    -- 作者关注数
+                collected_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_tweet_author ON tweets(author_id);
+            CREATE INDEX IF NOT EXISTS idx_tweet_id ON tweets(tweet_id);
+            CREATE INDEX IF NOT EXISTS idx_tweet_created ON tweets(created_at);
+        ''')
+        self.conn.commit()
+
+    def get_successful_user_count(self) -> int:
+        """获取已成功爬取推文的用户数量"""
+        try:
+            self.cursor.execute(
+                "SELECT COUNT(DISTINCT author_id) FROM tweets"
+            )
+            return self.cursor.fetchone()[0]
+        except Exception as e:
+            self.logger.error(f"Error getting successful user count: {e}")
+            return len(self.processed_users)
+
+    def load_users(self) -> List[Dict]:
+        source_conn = sqlite3.connect(self.source_db)
+        
+        # 计算还需要处理的用户数量
+        successful_count = self.get_successful_user_count()
+        remaining_target = max(0, self.target_user_count - successful_count)
+        
+        # 如果已经达到目标，返回空列表
+        if remaining_target <= 0:
+            self.logger.info(f"Already reached target user count: {self.target_user_count}")
+            source_conn.close()
+            return []
+
+        # 考虑到可能有用户没有推文，多取一些用户
+        fetch_limit = remaining_target * 2
+
+        # 排除已处理和无推文的用户
+        excluded_users = self.processed_users.union(self.no_tweets_users)
+        if excluded_users:
+            placeholders = ','.join(['?' for _ in excluded_users])
+            query = f"""
+                SELECT user_id, name 
+                FROM users 
+                WHERE user_id NOT IN ({placeholders})
+                LIMIT {fetch_limit}
+            """
+            df = pd.read_sql_query(query, source_conn, params=list(excluded_users))
+        else:
+            query = f"""
+                SELECT user_id, name 
+                FROM users 
+                LIMIT {fetch_limit}
+            """
+            df = pd.read_sql_query(query, source_conn)
+        
+        source_conn.close()
+        users = df.to_dict('records')
+        self.logger.info(
+            f"Loaded {len(users)} new users to process. "
+            f"Current successful users: {successful_count}, Target: {self.target_user_count}"
+        )
+        return users
+
+    async def check_api_quota(self) -> bool:
+        """检查API配额，如果配额不足返回False"""
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(f"{self.base_url}/quota", headers=self.headers) as response:
+                    if response.status == 200:
+                        quota_data = await response.json()
+                        remaining = quota_data.get('remaining', 0)
+                        self.logger.info(f"Current API quota remaining: {remaining}")
+                        return remaining >= 100 # 降低保留配额到100
+        except Exception as e:
+            self.logger.error(f"Error checking API quota: {e}")
+            return False
+        return True
+
+    async def get_user_tweets(self, user: Dict, max_tweets: int = 200) -> List[Dict]:
+        try:
+            url = f"{self.base_url}/user-tweets"
+            all_tweets = []
+            cursor = ""
+            retries = 3
+
+            while len(all_tweets) < max_tweets:
+                if self.api_call_count >= self.warning_threshold:
+                    quota_ok = await self.check_api_quota()
+                    if not quota_ok and self.api_call_count % 100 == 0:  
+                        self.logger.warning(f"API calls: {self.api_call_count}, checking quota...")
+                        if not await self.check_api_quota():
+                            raise QuotaLowException("API quota running low")
+
+                data = {
+                    "user_id": user['user_id'],
+                    "cursor": cursor,
+                    "limit": 200
+                }
+
+                got_response = False
+                for attempt in range(retries):
+                    try:
+                        async with aiohttp.ClientSession() as session:
+                            async with session.post(url, headers=self.headers, json=data, timeout=30) as response:
+                                if response.status == 200:
+                                    got_response = True
+                                    self.api_call_count += 1
+                                    response_data = await response.json()
+                                    tweets = response_data.get('tweets', [])
+
+                                    if not tweets:
+                                        self.logger.info(
+                                            f"No more tweets available for user {user['name']}. "
+                                            f"Collected {len(all_tweets)} tweets."
+                                        )
+                                        return all_tweets
+
+                                    # 为每条推文添加类型标记
+                                    for tweet in tweets:
+                                        if tweet.get('retweeted_status'):
+                                            tweet['tweet_type'] = 'retweet'
+                                        elif tweet.get('is_quote_status'):
+                                            tweet['tweet_type'] = 'quote'
+                                        else:
+                                            tweet['tweet_type'] = 'original'
+
+                                    all_tweets.extend(tweets)
+
+                                    # 记录各类推文的数量
+                                    type_counts = {
+                                        'original': len([t for t in tweets if t['tweet_type'] == 'original']),
+                                        'retweet': len([t for t in tweets if t['tweet_type'] == 'retweet']),
+                                        'quote': len([t for t in tweets if t['tweet_type'] == 'quote'])
+                                    }
+
+                                    self.logger.info(
+                                        f"User {user['name']}: Got {len(tweets)} tweets "
+                                        f"(Original: {type_counts['original']}, "
+                                        f"Retweet: {type_counts['retweet']}, "
+                                        f"Quote: {type_counts['quote']}). "
+                                        f"Current total: {len(all_tweets)}"
+                                    )
+
+                                    cursor = response_data.get('next_cursor')
+                                    if not cursor or len(all_tweets) >= max_tweets:
+                                        # 如果达到目标数量，截断到指定数量
+                                        return all_tweets[:max_tweets]
+
+                                    break  # 成功获取数据，跳出重试循环
+                                
+                                elif response.status == 429:
+                                    wait_time = int(response.headers.get('Retry-After', 60))
+                                    self.logger.warning(f"Rate limited, waiting {wait_time} seconds")
+                                    await asyncio.sleep(wait_time)
+                                elif response.status == 403:
+                                    self.logger.error(f"Access forbidden for user {user['name']}")
+                                    return []  # 只有在被禁止访问时才返回空列表
+                                elif response.status == 404:
+                                    self.logger.error(f"User {user['name']} not found")
+                                    return []  # 用户不存在时返回空列表
+                                else:
+                                    self.logger.error(
+                                        f"Failed to get tweets for {user['name']}: "
+                                        f"Status {response.status}, Response: {await response.text()}"
+                                    )
+                                    if attempt == retries - 1:
+                                        if got_response:
+                                            return all_tweets  # 如果之前成功获取过推文，返回已有的
+                                        return []  # 否则返回空列表
+                    except Exception as e:
+                        self.logger.error(f"Request error: {str(e)}")
+                        if attempt == retries - 1:
+                            if got_response:
+                                return all_tweets  # 如果之前成功获取过推文，返回已有的
+                            return []  # 否则返回空列表
+                        await asyncio.sleep(5)
+
+                await asyncio.sleep(3)  # 请求间隔
+
+            return all_tweets  # 达到目标数量时返回
+
+        except QuotaLowException:
+            raise
+        except Exception as e:
+            self.logger.error(f"Error getting tweets for {user['name']}: {str(e)}")
+            return []
+
+    def save_tweet(self, user: Dict, tweet_data: Dict) -> bool:
+        try:
+            created_at = parsedate_to_datetime(tweet_data.get('created_at'))
+
+            # 提取用户信息
+            user_info = tweet_data.get('user', {})
+
+            # 准备引用推文和转发推文的数据
+            quoted_status = tweet_data.get('quoted_status')
+            retweeted_status = tweet_data.get('retweeted_status')
+
+            self.cursor.execute('''
+                INSERT OR REPLACE INTO tweets 
+                (tweet_id, author_id, author_name, full_text, created_at, 
+                 likes_count, retweets_count, replies_count, views_count,
+                 quote_count, is_quote_status, conversation_id, in_reply_to_status_id,
+                 quoted_status, retweeted_status, entities,
+                 author_avatar, author_description, author_followers_count, 
+                 author_friends_count, collected_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+            ''', (
+                tweet_data.get('id_str'),
+                user['user_id'],
+                user['name'],
+                tweet_data.get('full_text', ''),
+                created_at,
+                tweet_data.get('favorite_count', 0),
+                tweet_data.get('retweet_count', 0),
+                tweet_data.get('reply_count', 0),
+                tweet_data.get('view_count', 0),
+                tweet_data.get('quote_count', 0),
+                tweet_data.get('is_quote_status', False),
+                tweet_data.get('conversation_id_str'),
+                tweet_data.get('in_reply_to_status_id_str'),
+                json.dumps(quoted_status) if quoted_status else None,
+                json.dumps(retweeted_status) if retweeted_status else None,
+                json.dumps(tweet_data.get('entities', {})),
+                user_info.get('avatar'),
+                user_info.get('description'),
+                user_info.get('followers_count'),
+                user_info.get('friends_count')
+            ))
+            self.conn.commit()
+            return True
+        except Exception as e:
+            self.logger.error(f"Error saving tweet: {str(e)}")
+            self.conn.rollback()
+            return False
+
+    async def process_user(self, user: Dict):
+        try:
+            # 检查是否需要切换日志文件
+            if datetime.now() >= self.next_log_rotation:
+                self._rotate_log_file()
+            
+            # 检查是否需要定时保存
+            if datetime.now() - self.last_save_time > self.save_interval:
+                self._save_processed_users()
+                self._save_no_tweets_users()
+                self.last_save_time = datetime.now()
+                
+            if user['user_id'] in self.processed_users or user['user_id'] in self.no_tweets_users:
+                self.logger.info(f"Skipping already processed user {user['name']}")
+                return
+
+            tweets = await self.get_user_tweets(user, max_tweets=100)
+            
+            if not tweets:
+                self.logger.info(f"No tweets found for user {user['name']}")
+                self.no_tweets_users.add(user['user_id'])
+                self._save_no_tweets_users()
+                return
+
+            self.logger.info(f"Processing {len(tweets)} tweets for user {user['name']}")
+
+            success = True
+            for tweet in tweets:
+                if not self.save_tweet(user, tweet):
+                    success = False
+                    break
+
+            if success:
+                self.processed_users.add(user['user_id'])
+                self._save_processed_users()
+                self.logger.info(f"Successfully processed user {user['name']}")
+
+        except QuotaLowException:
+            raise
+        except Exception as e:
+            self.logger.error(f"Error processing user {user['name']}: {str(e)}")
+
+    async def run(self):
+        try:
+            while True:
+                users = self.load_users()
+                if not users:
+                    self.logger.info("No more users to process or reached target count")
+                    break
+
+                for user in users:
+                    try:
+                        await self.process_user(user)
+                        # 检查是否已达到目标用户数
+                        if self.get_successful_user_count() >= self.target_user_count:
+                            self.logger.info(f"Reached target user count: {self.target_user_count}")
+                            return
+                    except QuotaLowException:
+                        self.logger.info(f"API quota running low, stopping at user {user['name']}")
+                        return
+                    
+                    await asyncio.sleep(2)  # 控制请求频率
+                
+        except Exception as e:
+            self.logger.error(f"Unexpected error in main loop: {str(e)}")
+            raise  # 重新抛出异常以便外层捕获
+        finally:
+            try:
+                self._save_processed_users()
+                self._save_no_tweets_users()
+                self.conn.close()
+            except Exception as e:
+                self.logger.error(f"Error during cleanup: {str(e)}")
+
+async def main():
+    crawler = None
+    try:
+        crawler = ArticleCrawler(
+            api_key="Enter your API KEY",
+            source_db="filtered_users.db",
+            target_user_count=800,  # 设置目标用户数
+            output_db="tweetsFor800.db"   # 指定输出数据库文件名
+        )
+        await crawler.run()
+    except KeyboardInterrupt:
+        print("\nReceived shutdown signal, cleaning up...")
+    except Exception as e:
+        print(f"Critical error: {str(e)}")
+    finally:
+        if crawler:
+            crawler.conn.close()  # 确保数据库连接被关闭
+
+if __name__ == "__main__":
+    asyncio.run(main())

03GetTweetsFor800Users/filtered_users.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:297b29029aaf2b55c5018c0e115d0e7677bf0bc38ebe531248be56af0e344f34
+size 3432448

03GetTweetsFor800Users/requirements.txt

@@ -0,0 +1,3 @@
+aiohttp>=3.8.0
+pandas>=1.5.0
+python-dateutil>=2.8.0

03GetTweetsFor800Users/result/tweetsFor800.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c6e634208bccd92717e3790f3abce488515c4f57054bcf5ac0a88764130a30e
+size 111566848