feat: 快手视频评论爬取done；数据保存到DB、CSV done

media_platform/kuaishou/client.py

@@ -1,16 +1,16 @@
 # -*- coding: utf-8 -*-
 import asyncio
 import json
+from typing import Any, Callable, Dict, Optional
 from urllib.parse import urlencode
-from typing import Dict, Optional
 
 import httpx
 from playwright.async_api import BrowserContext, Page
 
 from tools import utils
 
-from .graphql import KuaiShouGraphQL
 from .exception import DataFetchError, IPBlockError
+from .graphql import KuaiShouGraphQL
 
 
 class KuaiShouClient:
@@ -31,7 +31,7 @@ class KuaiShouClient:
         self.cookie_dict = cookie_dict
         self.graphql = KuaiShouGraphQL()
 
-    async def request(self, method, url, **kwargs) -> Dict:
+    async def request(self, method, url, **kwargs) -> Any:
         async with httpx.AsyncClient(proxies=self.proxies) as client:
             response = await client.request(
                 method, url, timeout=self.timeout,
@@ -89,7 +89,6 @@ class KuaiShouClient:
         }
         return await self.post("", post_data)
 
-
     async def get_video_info(self, photo_id: str) -> Dict:
         """
         Kuaishou web video detail api
@@ -105,3 +104,71 @@ class KuaiShouClient:
             "query": self.graphql.get("video_detail")
         }
         return await self.post("", post_data)
+
+    async def get_video_comments(self, photo_id: str, pcursor: str = "") -> Dict:
+        """get video comments
+        :param photo_id: photo id you want to fetch
+        :param pcursor: last you get pcursor, defaults to ""
+        :return:
+        """
+        post_data = {
+            "operationName": "commentListQuery",
+            "variables": {
+                "photoId": photo_id,
+                "pcursor": pcursor
+            },
+            "query": self.graphql.get("comment_list")
+
+        }
+        return await self.post("", post_data)
+
+    async def get_video_sub_comments(
+            self, note_id: str,
+            root_comment_id: str,
+            num: int = 30, cursor: str = ""
+    ):
+        """
+        get note sub comments
+        :param note_id: note id you want to fetch
+        :param root_comment_id: parent comment id
+        :param num: recommend 30, if num greater 30, it only return 30 comments
+        :param cursor: last you get cursor, defaults to ""
+        :return: {"has_more": true,"cursor": "6422442d000000000700dcdb",comments: [],"user_id": "63273a77000000002303cc9b","time": 1681566542930}
+        """
+        uri = "/api/sns/web/v2/comment/sub/page"
+        params = {
+            "note_id": note_id,
+            "root_comment_id": root_comment_id,
+            "num": num,
+            "cursor": cursor,
+        }
+        return await self.get(uri, params)
+
+    async def get_video_all_comments(self, photo_id: str, crawl_interval: float = 1.0, is_fetch_sub_comments=False,
+                                     callback: Optional[Callable] = None, ):
+        """
+        get video all comments include sub comments
+        :param photo_id:
+        :param crawl_interval:
+        :param is_fetch_sub_comments:
+        :param callback:
+        :return:
+        """
+
+        result = []
+        pcursor = ""
+        while pcursor != "no_more":
+            comments_res = await self.get_video_comments(photo_id, pcursor)
+            vision_commen_list = comments_res.get("visionCommentList", {})
+            pcursor = vision_commen_list.get("pcursor", "")
+            comments = vision_commen_list.get("rootComments", [])
+
+            if callback:  # 如果有回调函数，就执行回调函数
+                await callback(photo_id, comments)
+
+            await asyncio.sleep(crawl_interval)
+            if not is_fetch_sub_comments:
+                result.extend(comments)
+                continue
+            # todo handle get sub comments
+        return result

media_platform/kuaishou/core.py

@@ -1,5 +1,8 @@
 import asyncio
 import os
+import random
+import time
+from asyncio import Task
 from typing import Dict, List, Optional, Tuple
 
 from playwright.async_api import (BrowserContext, BrowserType, Page,
@@ -8,13 +11,13 @@ from playwright.async_api import (BrowserContext, BrowserType, Page,
 import config
 from base.base_crawler import AbstractCrawler
 from base.proxy_account_pool import AccountPool
-from tools import utils
-from var import crawler_type_var
 from models import kuaishou
+from tools import utils
+from var import comment_tasks_var, crawler_type_var
 
 from .client import KuaiShouClient
-from .login import KuaishouLogin
 from .exception import DataFetchError
+from .login import KuaishouLogin
 
 
 class KuaishouCrawler(AbstractCrawler):
@@ -109,9 +112,6 @@ class KuaishouCrawler(AbstractCrawler):
     async def get_specified_notes(self):
         pass
 
-    async def batch_get_video_comments(self, video_id_list: List[str]):
-        utils.logger.info(f"[batch_get_video_comments] video ids:{video_id_list}")
-
     async def get_video_info_task(self, video_id: str, semaphore: asyncio.Semaphore) -> Optional[Dict]:
         """Get video detail task"""
         async with semaphore:
@@ -126,6 +126,52 @@ class KuaishouCrawler(AbstractCrawler):
                 utils.logger.error(f"have not fund note detail video_id:{video_id}, err: {ex}")
                 return None
 
+    async def batch_get_video_comments(self, video_id_list: List[str]):
+        """
+        batch get video comments
+        :param video_id_list:
+        :return:
+        """
+        utils.logger.info(f"[batch_get_video_comments] video ids:{video_id_list}")
+        semaphore = asyncio.Semaphore(config.MAX_CONCURRENCY_NUM)
+        task_list: List[Task] = []
+        for video_id in video_id_list:
+            task = asyncio.create_task(self.get_comments(video_id, semaphore), name=video_id)
+            task_list.append(task)
+
+        comment_tasks_var.set(task_list)
+        await asyncio.gather(*task_list)
+
+    async def get_comments(self, video_id: str, semaphore: asyncio.Semaphore):
+        """
+        get comment for video id
+        :param video_id:
+        :param semaphore:
+        :return:
+        """
+        async with semaphore:
+            try:
+                await self.ks_client.get_video_all_comments(
+                    photo_id=video_id,
+                    crawl_interval=random.random(),
+                    callback=kuaishou.batch_update_ks_video_comments
+                )
+            except DataFetchError as ex:
+                utils.logger.error(f"Get video_id: {video_id} comment error: {ex}")
+            except Exception as e:
+                utils.logger.error(f"map by been blocked, err:", e)
+                # use time.sleeep block main coroutine instead of asyncio.sleep and cacel running comment task
+                # maybe kuaishou block our request, we will take a nap and update the cookie again
+                current_running_tasks = comment_tasks_var.get()
+                for task in current_running_tasks:
+                    task.cancel()
+                time.sleep(20)
+                await self.context_page.goto(f"{self.index_url}?isHome=1")
+                await self.ks_client.update_cookies(browser_context=self.browser_context)
+
+
+
+
     def create_proxy_info(self) -> Tuple[Optional[str], Optional[Dict], Optional[str]]:
         """Create proxy info for playwright and httpx"""
         # phone: 13012345671  ip_proxy: 111.122.xx.xx1:8888

media_platform/kuaishou/graphql.py

@@ -1,10 +1,10 @@
 # 快手的数据传输是基于GraphQL实现的
 # 这个类负责获取一些GraphQL的schema
-import os
+from typing import  Dict
 
 
 class KuaiShouGraphQL:
-    graphql_queries = {}
+    graphql_queries: Dict[str, str]= {}
 
     def __init__(self):
         self.graphql_dir = "media_platform/kuaishou/graphql/"

media_platform/kuaishou/graphql/comment_list.graphql

@@ -0,0 +1,39 @@
+query commentListQuery($photoId: String, $pcursor: String) {
+  visionCommentList(photoId: $photoId, pcursor: $pcursor) {
+    commentCount
+    pcursor
+    rootComments {
+      commentId
+      authorId
+      authorName
+      content
+      headurl
+      timestamp
+      likedCount
+      realLikedCount
+      liked
+      status
+      authorLiked
+      subCommentCount
+      subCommentsPcursor
+      subComments {
+        commentId
+        authorId
+        authorName
+        content
+        headurl
+        timestamp
+        likedCount
+        realLikedCount
+        liked
+        status
+        authorLiked
+        replyToUserName
+        replyTo
+        __typename
+      }
+      __typename
+    }
+    __typename
+  }
+}