Added tweets from nine users

03Added/Added_user_tweets.db

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

03Added/requirements.txt

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

03Added/spi06-4-2.py

@@ -0,0 +1,393 @@
+import aiohttp
+import asyncio
+import json
+import logging
+import sqlite3
+from datetime import datetime, timedelta
+from email.utils import parsedate_to_datetime
+from typing import List, Dict, Set
+from pathlib import Path
+
+class QuotaLowException(Exception):
+    pass
+
+class UserTweetsCrawler:
+    def __init__(self, api_key: str, users_file: str, output_db: str = "user_tweets.db"):
+        self.api_key = api_key
+        self.base_url = "https://api.tweetscout.io/v2"
+        self.users_file = users_file
+        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
+        self.last_save_time = datetime.now()
+        self.save_interval = timedelta(minutes=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 _setup_logging(self):
+        self.logger = logging.getLogger("UserTweetsCrawler")
+        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)
+        
+        file_handler = logging.FileHandler(f"crawler_{datetime.now().strftime('%Y%m%d_%H%M')}.log", encoding='utf-8')
+        file_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+        self.logger.addHandler(file_handler)
+
+    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,
+                retweeted_status TEXT,
+                entities TEXT,
+                author_avatar TEXT,
+                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 load_users(self) -> List[Dict]:
+        try:
+            with open(self.users_file, 'r', encoding='utf-8') as f:
+                screen_names = [name.strip() for name in f.read().split(',')]
+            
+            users = []
+            for screen_name in screen_names:
+                if screen_name and screen_name not in self.processed_users and screen_name not in self.no_tweets_users:
+                    users.append({
+                        'screen_name': screen_name,
+                        'name': screen_name  # 用于日志显示
+                    })
+            
+            self.logger.info(f"Loaded {len(users)} users to process")
+            return users
+        except Exception as e:
+            self.logger.error(f"Error loading users from file: {e}")
+            return []
+
+    async def check_api_quota(self) -> bool:
+        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
+        except Exception as e:
+            self.logger.error(f"Error checking API quota: {e}")
+            return False
+        return True
+
+    async def get_user_id(self, screen_name: str) -> str:
+        try:
+            url = f"{self.base_url}/handle-to-id/{screen_name}"
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, headers=self.headers, timeout=30) as response:
+                    self.logger.info(f"Attempting to get user ID for {screen_name}")
+                    if response.status == 200:
+                        data = await response.json()
+                        user_id = data.get('id')
+                        self.logger.info(f"Successfully got user ID for {screen_name}: {user_id}")
+                        return user_id
+                    else:
+                        self.logger.error(f"Failed to get user ID for {screen_name}: Status {response.status}")
+                        return None
+        except asyncio.TimeoutError:
+            self.logger.error(f"Timeout while getting user ID for {screen_name}")
+            return None
+        except Exception as e:
+            self.logger.error(f"Error getting user ID for {screen_name}: {e}")
+            return None
+
+    async def get_user_tweets(self, user: Dict, max_tweets: int = 100) -> List[Dict]:
+        try:
+            url = f"{self.base_url}/user-tweets"
+            all_tweets = []
+            cursor = ""
+            retries = 3
+
+            # 先获取用户ID
+            user_id = await self.get_user_id(user['screen_name'])
+            if not user_id:
+                self.logger.error(f"Could not get user ID for {user['screen_name']}")
+                return []
+
+            user['user_id'] = user_id
+
+            while len(all_tweets) < max_tweets:
+                if self.api_call_count >= self.warning_threshold:
+                    if not await self.check_api_quota():
+                        raise QuotaLowException("API quota running low")
+
+                data = {
+                    "user_id": user_id,
+                    "cursor": cursor
+                }
+
+                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:
+                                        return all_tweets
+
+                                    all_tweets.extend(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)
+                                else:
+                                    self.logger.error(f"Failed to get tweets: Status {response.status}")
+                                    if attempt == retries - 1:
+                                        return all_tweets if got_response else []
+                    except Exception as e:
+                        self.logger.error(f"Request error: {str(e)}")
+                        if attempt == retries - 1:
+                            return all_tweets if got_response else []
+                        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: {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['screen_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:
+            self.logger.info(f"Starting to process user {user['screen_name']}")
+
+            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()
+
+            # 获取用户ID
+            self.logger.info(f"Getting user ID for {user['screen_name']}")
+            user_id = await self.get_user_id(user['screen_name'])
+            if not user_id:
+                self.logger.error(f"Failed to get user ID for {user['screen_name']}, skipping")
+                return
+
+            user['user_id'] = user_id
+            self.logger.info(f"Successfully got user ID {user_id} for {user['screen_name']}")
+
+            tweets = await self.get_user_tweets(user, max_tweets=100)
+
+            if not tweets:
+                self.logger.info(f"No tweets found for user {user['screen_name']}")
+                self.no_tweets_users.add(user['screen_name'])
+                self._save_no_tweets_users()
+                return
+
+            self.logger.info(f"Processing {len(tweets)} tweets for user {user['screen_name']}")
+
+            success = True
+            for i, tweet in enumerate(tweets, 1):
+                if i % 10 == 0:
+                    self.logger.info(f"Processed {i}/{len(tweets)} tweets for {user['screen_name']}")
+                if not self.save_tweet(user, tweet):
+                    success = False
+                    break
+
+            if success:
+                self.processed_users.add(user['screen_name'])
+                self._save_processed_users()
+                self.logger.info(f"Successfully processed user {user['screen_name']}")
+
+        except QuotaLowException:
+            raise
+        except Exception as e:
+            self.logger.error(f"Error processing user {user['screen_name']}: {str(e)}")
+            import traceback
+            self.logger.error(traceback.format_exc())
+
+    async def run(self):
+        try:
+            users = self.load_users()
+            if not users:
+                self.logger.info("No users to process")
+                return
+
+            for user in users:
+                try:
+                    await self.process_user(user)
+                except QuotaLowException:
+                    self.logger.info(f"API quota running low, stopping at user {user['screen_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 = UserTweetsCrawler(
+            api_key="aa6e0836-6bef-426e-8abb-db8dde0d0f68",
+            users_file="users.txt",
+            output_db="Added_user_tweets.db"
+        )
+        print("Crawler initialized, starting process...")
+        await crawler.run()
+    except KeyboardInterrupt:
+        print("\nReceived shutdown signal, cleaning up...")
+    except Exception as e:
+        print(f"Critical error: {str(e)}")
+        import traceback
+        print(traceback.format_exc())
+    finally:
+        if crawler:
+            print("Closing database connection...")
+            crawler.conn.close()
+            print("Cleanup completed")
+
+if __name__ == "__main__":
+    print("Starting crawler...")
+    asyncio.run(main())

03Added/users.txt

@@ -0,0 +1 @@
+zlexdl,HM010169,btcyusheng,fairyclub777,WY_mask,btc100000015252,0xpcp_,Baili1018,nancy_c813