Upload 01GetFollowing

01GetFollowing/following.db

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

01GetFollowing/requirements.txt

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

01GetFollowing/result/following_expanded.db

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

01GetFollowing/u03-5-4.py

@@ -0,0 +1,442 @@
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+import json
+import logging
+import sqlite3
+import time
+from datetime import datetime
+import urllib3
+import os
+from typing import List, Dict, Any, Optional, Set
+
+# Disable SSL warnings
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+class FollowingCrawlerV5:
+    def __init__(self, api_key: str, input_db: str, output_db: str = None):
+        self.api_key = api_key
+        self.base_url = "https://api.tweetscout.io/v2"
+        self.input_db = input_db
+        self.output_db = output_db or "following_expanded.db"
+        self.progress_db = "crawler_progress.db"
+        self.headers = {
+            "ApiKey": api_key,
+            "Accept": "application/json"
+        }
+        self.session = self._create_session()
+        self._setup_logging()
+        self._init_databases()
+
+    def _create_session(self) -> requests.Session:
+        session = requests.Session()
+
+        retry_strategy = Retry(
+            total=3,            
+            backoff_factor=10,    # 基础等待时间
+            status_forcelist=[429, 500, 502, 503, 504, 520, 521, 522, 523, 524, 525, 526, 527, 528, 598, 599],  # 增加更多状态码
+            allowed_methods=["GET", "POST", "HEAD", "PUT", "DELETE", "OPTIONS", "TRACE"],
+            respect_retry_after_header=True,
+            raise_on_status=False
+        )
+
+        adapter = HTTPAdapter(
+            max_retries=retry_strategy,
+            pool_maxsize=10,      
+            pool_block=True
+        )
+
+        session.mount("http://", adapter)
+        session.mount("https://", adapter)
+        session.verify = False
+
+        # 设置更长的超时
+        session.timeout = (60, 120)  # 连接超时60秒，读取超时180秒
+
+        return session
+
+
+
+    def _setup_logging(self):
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(levelname)s - %(message)s',
+            handlers=[
+                logging.FileHandler('crawler_expanded.log'),
+                logging.StreamHandler()
+            ]
+        )
+        self.logger = logging.getLogger("FollowingCrawlerV5")
+
+    def _init_databases(self):
+        # Initialize progress tracking database
+        self.progress_conn = sqlite3.connect(self.progress_db)
+        self.progress_cursor = self.progress_conn.cursor()
+        self.progress_cursor.execute('''
+            CREATE TABLE IF NOT EXISTS processed_users (
+                user_id TEXT PRIMARY KEY,
+                processed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+            )
+        ''')
+        self.progress_conn.commit()
+
+        # Initialize output database
+        if not os.path.exists(self.output_db):
+            self.output_conn = sqlite3.connect(self.output_db)
+            self.output_cursor = self.output_conn.cursor()
+            
+            self.output_cursor.executescript('''
+                CREATE TABLE IF NOT EXISTS users (
+                    user_id TEXT PRIMARY KEY,
+                    name TEXT,
+                    screen_name TEXT,
+                    description TEXT,
+                    followers_count INTEGER,
+                    friends_count INTEGER,
+                    tweets_count INTEGER,
+                    register_date TEXT,
+                    avatar TEXT,
+                    banner TEXT,
+                    verified BOOLEAN,
+                    can_dm BOOLEAN,
+                    last_updated TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                );
+                
+                CREATE TABLE IF NOT EXISTS following_relationships (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    user_id TEXT,
+                    following_of TEXT,
+                    collected_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    UNIQUE(user_id, following_of),
+                    FOREIGN KEY(user_id) REFERENCES users(user_id)
+                );
+                
+                CREATE INDEX IF NOT EXISTS idx_user_id ON users(user_id);
+                CREATE INDEX IF NOT EXISTS idx_followers_count ON users(followers_count);
+                CREATE INDEX IF NOT EXISTS idx_following_rel ON following_relationships(user_id, following_of);
+            ''')
+            self.output_conn.commit()
+        else:
+            self.output_conn = sqlite3.connect(self.output_db)
+            self.output_cursor = self.output_conn.cursor()
+
+    def get_unprocessed_users(self, batch_size: int = 100) -> List[Dict[str, Any]]:
+        input_conn = sqlite3.connect(self.input_db)
+        input_cursor = input_conn.cursor()
+
+        try:
+            self.logger.info("Starting to fetch unprocessed users...")  
+
+            self.progress_cursor.execute("ATTACH DATABASE ? AS input_db", (self.input_db,))
+
+            # 检查用户处理状态
+            self.progress_cursor.execute(
+                "SELECT user_id FROM processed_users WHERE user_id IN (SELECT user_id FROM input_db.users WHERE screen_name = ?)", 
+                ('vc_btxcap',)
+            )
+            result = self.progress_cursor.fetchone()
+            self.logger.info(f"User vc_btxcap processed status: {'Already processed' if result else 'Not processed'}")
+
+            # 获取未处理的用户
+            query = '''
+                SELECT DISTINCT u.user_id, u.screen_name, u.followers_count
+                FROM input_db.users u
+                WHERE u.user_id NOT IN (
+                    SELECT user_id FROM processed_users
+                )
+                LIMIT ?
+            '''
+
+            self.progress_cursor.execute(query, (batch_size,))
+            users = [
+                {
+                    "user_id": row[0],
+                    "screen_name": row[1],
+                    "followers_count": row[2]
+                }
+                for row in self.progress_cursor.fetchall()
+            ]
+
+            # 断开数据库连接
+            self.progress_cursor.execute("DETACH DATABASE input_db")
+
+            self.logger.info(f"Found {len(users)} unprocessed users")
+            if users:
+                self.logger.info(f"First unprocessed user: {users[0]['screen_name']}")
+
+            return users
+        
+        except Exception as e:
+            self.logger.error(f"Error getting unprocessed users: {str(e)}")
+            return []
+        finally:
+            input_conn.close()
+
+    def get_user_following(self, user: Dict[str, Any], retries: int = 1) -> List[Dict[str, Any]]:  # 增加重试次数
+        all_following = []
+        retry_count = 0
+        cursor = None
+        base_wait_time = 20  # 基础等待时间
+        
+        while True:
+            try:
+                url = f"{self.base_url}/follows"
+                params = {
+                    "user_id": user['user_id'],
+                    "limit": 20
+                }
+
+                if cursor:
+                    params['cursor'] = cursor
+
+                # 增加请求前的等待时间
+                # wait_time = base_wait_time + (len(all_following) // 100) * 10  # 每100条数据增加10秒等待
+                self.logger.info(f"Waiting {base_wait_time} seconds before next request...")
+                time.sleep(base_wait_time)
+
+                response = self.session.get(
+                    url, 
+                    headers=self.headers, 
+                    params=params,
+                    timeout=(30, 60)  # 匹配session的超时设置
+                )
+
+                if response.status_code == 200:
+                    data = response.json()
+                    if isinstance(data, list):
+                        retry_count = 0
+                        cursor = response.headers.get('x-pagination-cursor')
+                        all_following.extend(data)
+
+                        self.logger.info(
+                            f"Retrieved batch of {len(data)} following for {user['screen_name']}, "
+                            f"total: {len(all_following)}"
+                        )
+
+                        if not cursor:
+                            break
+
+                elif response.status_code == 429:
+                    retry_after = int(response.headers.get('Retry-After', 30))  # 默认等待时间增30秒
+                    self.logger.warning(f"Rate limited. Waiting {retry_after} seconds...")
+                    time.sleep(retry_after + 5)  # 额外等待5秒
+                    continue
+
+                else:
+                    raise requests.exceptions.RequestException(
+                        f"Status {response.status_code}, {response.text}"
+                    )
+
+            except Exception as e:
+                retry_count += 1
+                self.logger.error(f"Error getting following for {user['screen_name']}: {str(e)}")
+                
+                if retry_count >= retries:
+                    self.logger.warning(
+                        f"Max retries reached for {user['screen_name']}, recording failure and moving on..."
+                    )
+                    # 记录失败的用户
+                    with open('failed_users.txt', 'a') as f:
+                        f.write(f"{user['screen_name']},{user['user_id']},{datetime.now()}\n")
+                    return []  # 直接返回空列表，跳过这个用户
+                
+                wait_time = min(120, base_wait_time * (2 ** retry_count))  # 最多等待2分钟
+                self.logger.info(f"Waiting {wait_time} seconds before retry {retry_count}")
+                time.sleep(wait_time)
+
+        filtered_following = [
+            f for f in all_following 
+            if isinstance(f.get('followers_count'), int) and f.get('followers_count', 0) > 5000
+        ]
+
+        self.logger.info(
+            f"Retrieved {len(filtered_following)} filtered following (>5000) "
+            f"for {user['screen_name']} out of {len(all_following)} total"
+        )
+
+        return filtered_following
+
+    def save_following(self, user: Dict[str, Any], following_of: str) -> None:
+        try:
+            # Insert or update user information
+            self.output_cursor.execute('''
+                INSERT OR REPLACE INTO users 
+                (user_id, name, screen_name, description, 
+                followers_count, friends_count, tweets_count,
+                register_date, avatar, banner, verified, can_dm,
+                last_updated)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+            ''', (
+                user.get('id'),
+                user.get('name'),
+                user.get('screen_name'),
+                user.get('description'),
+                user.get('followers_count', 0),
+                user.get('friends_count', 0),
+                user.get('tweets_count', 0),
+                user.get('register_date'),
+                user.get('avatar'),
+                user.get('banner'),
+                user.get('verified', False),
+                user.get('can_dm', False)
+            ))
+            
+            # Insert following relationship
+            self.output_cursor.execute('''
+                INSERT OR IGNORE INTO following_relationships 
+                (user_id, following_of)
+                VALUES (?, ?)
+            ''', (user.get('id'), following_of))
+            
+            self.output_conn.commit()
+            
+        except sqlite3.Error as e:
+            self.logger.error(f"Database error saving following: {str(e)}")
+            self.output_conn.rollback()
+        except Exception as e:
+            self.logger.error(f"Error saving following: {str(e)}")
+            self.output_conn.rollback()
+
+    def mark_user_processed(self, user_id: str) -> None:
+        try:
+            self.progress_cursor.execute('''
+                INSERT OR REPLACE INTO processed_users (user_id)
+                VALUES (?)
+            ''', (user_id,))
+            self.progress_conn.commit()
+        except sqlite3.Error as e:
+            self.logger.error(f"Error marking user as processed: {str(e)}")
+            self.progress_conn.rollback()
+
+    def process_user_batch(self, users: List[Dict[str, Any]]) -> None:
+        for user in users:
+            try:
+                self.logger.info(f"Processing user: {user['screen_name']}")
+                following_users = self.get_user_following(user)
+                
+                for idx, following_user in enumerate(following_users, 1):
+                    self.save_following(following_user, user['screen_name'])
+                    if idx % 100 == 0:
+                        self.logger.info(
+                            f"Processed {idx}/{len(following_users)} following "
+                            f"for {user['screen_name']}"
+                        )
+                    time.sleep(0.5)  # Increased delay between saves
+                
+                self.mark_user_processed(user['user_id'])
+                self.logger.info(
+                    f"Completed processing {len(following_users)} following "
+                    f"for {user['screen_name']}"
+                )
+                
+                # Longer pause between users
+                time.sleep(30)  # Increased to 30 seconds
+                
+            except Exception as e:
+                self.logger.error(f"Error processing user {user['screen_name']}: {str(e)}")
+                continue
+
+    def get_progress_stats(self) -> None:
+        try:
+            # Get total users to process from input database
+            input_conn = sqlite3.connect(self.input_db)
+            input_cursor = input_conn.cursor()
+            input_cursor.execute("SELECT COUNT(DISTINCT user_id) FROM users")
+            total_users = input_cursor.fetchone()[0]
+            input_conn.close()
+            
+            # Get processed users count
+            self.progress_cursor.execute("SELECT COUNT(*) FROM processed_users")
+            processed_users = self.progress_cursor.fetchone()[0]
+            
+            # Get collected relationships
+            self.output_cursor.execute("SELECT COUNT(*) FROM following_relationships")
+            total_relationships = self.output_cursor.fetchone()[0]
+            
+            self.logger.info(f"\nProgress Statistics:")
+            self.logger.info(f"Total users to process: {total_users}")
+            self.logger.info(f"Processed users: {processed_users}")
+            self.logger.info(f"Progress: {(processed_users/total_users)*100:.2f}%")
+            self.logger.info(f"Total following relationships collected: {total_relationships}")
+            
+        except sqlite3.Error as e:
+            self.logger.error(f"Error getting progress stats: {str(e)}")
+
+
+
+    def run(self, batch_size: int = 15):
+        max_retries = 3
+        retry_count = 0
+        
+        while retry_count < max_retries:
+            try:
+                self.logger.info("Starting expanded following crawler")
+                
+                # 读取上次的进度
+                last_processed_user = None
+                if os.path.exists('checkpoint.txt'):
+                    with open('checkpoint.txt', 'r') as f:
+                        last_processed_user = f.read().strip()
+                        self.logger.info(f"Resuming from user: {last_processed_user}")
+                
+                while True:
+                    users = self.get_unprocessed_users(batch_size)
+                    
+                    if users:
+                        self.logger.info("Debug - All users in batch:")
+                        for user in users:
+                            self.logger.info(f"  - {user['screen_name']}")
+                    
+                    if not users:
+                        break
+                        
+                    # 如果有断点，跳过直到找到上次处理的用户
+                    if last_processed_user:
+                        for idx, user in enumerate(users):
+                            self.logger.info(f"Checking user: {user['screen_name']}")
+                            if user['screen_name'] == last_processed_user:
+                                users = users[idx+1:]
+                                last_processed_user = None
+                                self.logger.info("Found checkpoint user!")
+                                break
+                            
+                    self.process_user_batch(users)
+                    
+                    # 记录最后处理的用户
+                    with open('checkpoint.txt', 'w') as f:
+                        f.write(users[-1]['screen_name'])
+                    
+                    self.get_progress_stats()
+                    batch_delay = 180  # 3分钟
+                    self.logger.info(f"Waiting {batch_delay} seconds before next batch...")
+                    time.sleep(batch_delay)
+                
+                break  # 成功完成，退出重试循环
+                
+            except Exception as e:
+                retry_count += 1
+                self.logger.error(f"Error in main run loop (attempt {retry_count}/{max_retries}): {str(e)}")
+                
+                if retry_count < max_retries:
+                    wait_time = 60 * retry_count  # 5分钟 * 重试次数
+                    self.logger.info(f"Waiting {wait_time} seconds before retrying...")
+                    time.sleep(wait_time)
+                else:
+                    self.logger.error("Max retries reached, stopping crawler")
+                    
+            finally:
+                self.progress_conn.close()
+                self.output_conn.close()
+                self.logger.info("Crawler finished, database connections closed")
+
+
+def main():
+    crawler = FollowingCrawlerV5(
+        api_key="Enter your API KEY",
+        input_db="following.db",
+        output_db="following_expanded.db"
+    )
+    crawler.run(batch_size=15)  # Process 15 users at a time
+
+if __name__ == "__main__":
+    main()