treehole.client

  1"""
  2树洞客户端，处理收发请求
  3"""
  4from functools import cache
  5from typing import Dict, List, Optional, Tuple, Union
  6
  7import aiofiles
  8import aiohttp
  9import requests
 10from requests.compat import urljoin
 11
 12from .models import Comment, Hole, UserName
 13from .utils import AuthError, EmptyError, logger
 14
 15__all__ = ["TreeHoleClient"]
 16
 17BASE_URL = "https://treehole.pku.edu.cn/api/"
 18REQUEST_HEADER = {}
 19BASE_QUERY = {}
 20
 21
 22class TreeHoleClient:
 23    """
 24    树洞交互客户端，低程度封装
 25    """
 26
 27    def __init__(
 28        self,
 29        token: Optional[str] = None,
 30        uid: Optional[Union[int, str]] = None,
 31        password: Optional[str] = None,
 32        header: Optional[Dict[str, str]] = None,
 33        base_param: Optional[Dict[str, str]] = None,
 34        base_url: Optional[str] = None,
 35    ) -> None:
 36        """
 37        - token:
 38            用户 token（可在树洞 cookies 中 pku_token 字段中获取）
 39        - uid:
 40            IAAA 账号 ID（可选的登录方式）
 41        - password:
 42            IAAA 账号密码（可选的登录方式）
 43        - header:
 44            额外的请求头，可选
 45        - base_param:
 46            额外的请求参数，可选
 47        - base_url:
 48            其他树洞 API 地址，可选
 49        """
 50        self.__base_url = base_url or BASE_URL
 51        if token:
 52            self.__token = token
 53        elif uid and password:
 54            __token = self.__auth(uid, password)
 55            if not __token:
 56                raise AuthError("Failed to login")
 57            self.__token = __token
 58        else:
 59            raise AuthError("No token or uid and password provided")
 60        self.__header = {
 61            **REQUEST_HEADER,
 62            **{"authorization": "Bearer " + self.__token},
 63            **(header or {}),
 64        }
 65        self.__base_param = {
 66            **BASE_QUERY,
 67            **(base_param or {}),
 68        }
 69
 70    def __auth(self, uid: Union[int, str], password: str) -> Optional[str]:
 71        """
 72        登录，获取 token
 73
 74        Parameters
 75        ----------
 76        - uid: IAAA 账号 ID
 77        - password: IAAA 账号密码
 78
 79        Returns
 80        -------
 81        1. token，登录失败则返回 `None`
 82        """
 83
 84        if not self.__is_num(uid):
 85            raise ValueError("uid must be an integer or string of interger")
 86        auth_data = {"uid": uid, "password": password}
 87        response = requests.post(
 88            self.login_url,
 89            data=auth_data,
 90        )
 91        if not self.__is_valid_response(response):
 92            return None
 93        response_dict = response.json()
 94        if not response_dict["success"]:
 95            logger.error("Failed to login, response: %s", response_dict)
 96            return None
 97        return response_dict["data"]["jwt"]
 98
 99    @property
100    def token(self) -> str:
101        """用户 token，只读"""
102        return self.__token
103
104    @property
105    def header(self) -> Dict[str, str]:
106        """请求头，只读"""
107        return self.__header
108
109    @property
110    def base_param(self) -> Dict[str, str]:
111        """请求参数，只读"""
112        return self.__base_param
113
114    @property
115    def base_url(self) -> str:
116        """请求地址，只读"""
117        return self.__base_url
118
119    @property
120    @cache
121    def login_url(self) -> str:
122        """登陆请求地址，只读"""
123        return urljoin(self.base_url, "login/")
124
125    @property
126    @cache
127    def hole_url(self) -> str:
128        """树洞请求地址，只读"""
129        return urljoin(self.base_url, "pku/")
130
131    @property
132    @cache
133    def holes_url(self) -> str:
134        """首页及搜索树洞请求地址，只读"""
135        return urljoin(self.base_url, "pku_hole/")
136
137    @property
138    @cache
139    def comment_url(self) -> str:
140        """树洞评论请求地址，只读"""
141        return urljoin(self.base_url, "pku_comment/")
142
143    @property
144    @cache
145    def follow_url(self) -> str:
146        """关注列表请求地址，只读"""
147        return urljoin(self.base_url, "follow/")
148
149    @property
150    @cache
151    def image_url(self) -> str:
152        """树洞图片请求地址，只读"""
153        return urljoin(self.base_url, "pku_image/")
154
155    @property
156    @cache
157    def attention_url(self) -> str:
158        """设置关注请求地址，只读"""
159        return urljoin(self.base_url, "pku_attention/")
160
161    @property
162    @cache
163    def report_url(self) -> str:
164        """举报请求地址，只读"""
165        return urljoin(self.base_url, "pku_report/")
166
167    @property
168    @cache
169    def store_url(self) -> str:
170        """举报请求地址，只读"""
171        return urljoin(self.base_url, "pku_store")
172
173    @staticmethod
174    def __is_num(pid: Union[int, str]) -> bool:
175        try:
176            int(pid)
177        except ValueError:
178            logger.exception("Invalid number: %s", pid)
179            return False
180        return True
181
182    @staticmethod
183    def __is_valid_response(response: requests.Response) -> bool:
184        if response.status_code != 200:
185            logger.error(
186                "Failed to get reponse, status code: %s, response: %s",
187                response.status_code,
188                response.reason,
189            )
190            return False
191        else:
192            return True
193
194    @staticmethod
195    def __is_valid_client_response(response: aiohttp.ClientResponse) -> bool:
196        if response.status != 200:
197            logger.error(
198                "Failed to get reponse, status code: %s, response: %s",
199                response.status,
200                response.reason,
201            )
202            return False
203        else:
204            return True
205
206    def get_hole_image(self, hole: Hole) -> Union[Tuple[bytes, str], Tuple[None, None]]:
207        """
208        获取树洞图片
209
210        Parameters
211        ----------
212        - hole:
213            任一树洞类
214
215        Returns
216        -------
217        1. 图片二进制数据，不包含图片或请求错误则返回 `None`
218        2. 图片类型，不包含图片或请求错误则返回 `None`
219        """
220
221        if hole.type == "image":
222            response = requests.get(
223                urljoin(self.image_url, str(hole.pid)), headers=self.header
224            )
225            if self.__is_valid_response(response):
226                return response.content, response.headers["Content-Type"]
227        return (None, None)
228
229    async def get_hole_image_async(
230        self, hole: Hole
231    ) -> Union[Tuple[bytes, str], Tuple[None, None]]:
232        """
233        异步获取树洞图片
234
235        Parameters
236        ----------
237        - hole: 任一树洞类
238
239        Returns
240        -------
241        1. 图片二进制数据，不包含图片或请求错误则返回 `None`
242        2. 图片类型，不包含图片或请求错误则返回 `None`
243        """
244
245        if hole.type == "image":
246            async with aiohttp.request(
247                "GET",
248                urljoin(self.image_url, str(hole.pid)),
249                headers=self.header,
250            ) as response:
251                if self.__is_valid_client_response(response):
252                    return (
253                        await response.content.read(),
254                        response.headers["Content-Type"],
255                    )
256        return (None, None)
257
258    def get_comment(
259        self,
260        pid: Union[int, str],
261        page: Union[int, str] = 1,
262        page_size: Union[int, str] = 500,
263    ) -> Optional[List[Comment]]:
264        """
265        获取树洞评论
266
267        Parameters
268        ----------
269        - pid: 树洞 ID
270        - page: 页码，默认为 1
271        - page_size: 每页评论数，默认为 500
272
273        Returns
274        -------
275        1. 评论列表，请求错误则返回 `None`
276        """
277
278        if not self.__is_num(pid):
279            raise ValueError("pid must be an integer or string of interger")
280        if not self.__is_num(page):
281            raise ValueError("page must be an integer or string of interger")
282        if not self.__is_num(page_size):
283            raise ValueError("page_size must be an integer or string of interger")
284        param = {
285            **self.base_param,
286            **{"page": str(page), "limit": str(page_size)},
287        }
288        response = requests.get(
289            urljoin(self.comment_url, str(pid)), params=param, headers=self.header
290        )
291        if not self.__is_valid_response(response):
292            return None
293        response_dict = response.json()
294        if not response_dict["success"]:
295            logger.error("Failed to get comment, response: %s", response_dict)
296            return None
297        return list(map(Comment.from_data, response_dict["data"]["data"]))
298
299    async def get_comment_async(
300        self,
301        pid: Union[int, str],
302        page: Union[int, str] = 1,
303        page_size: Union[int, str] = 500,
304    ) -> Optional[List[Comment]]:
305        """
306        异步获取树洞评论
307
308        Parameters
309        ----------
310        - pid: 树洞 ID
311        - page: 页码，默认为 1
312        - page_size: 每页评论数，默认为 500
313
314        Returns
315        -------
316        1. 评论列表，请求错误则返回 `None`
317        """
318
319        if not self.__is_num(pid):
320            raise ValueError("pid must be an integer or string of interger")
321        if not self.__is_num(page):
322            raise ValueError("page must be an integer or string of interger")
323        if not self.__is_num(page_size):
324            raise ValueError("page_size must be an integer or string of interger")
325        param = {
326            **self.base_param,
327            **{"page": str(page), "limit": str(page_size)},
328        }
329        async with aiohttp.request(
330            "GET",
331            urljoin(self.comment_url, str(pid)),
332            params=param,
333            headers=self.header,
334        ) as response:
335            if not self.__is_valid_client_response(response):
336                return None
337            response_dict = await response.json()
338            if not response_dict["success"]:
339                logger.error("Failed to get comment, response: %s", response_dict)
340                return None
341            return list(map(Comment.from_data, response_dict["data"]["data"]))
342
343    def get_hole(self, pid: Union[int, str]) -> Optional[Hole]:
344        """
345        获取单个树洞
346
347        Parameters
348        ----------
349        - pid: 树洞 ID
350
351        Returns
352        -------
353        1. 树洞，请求错误则返回 `None`
354        """
355
356        if not self.__is_num(pid):
357            raise ValueError("pid must be an integer or string of interger")
358        response = requests.get(
359            urljoin(self.hole_url, str(pid)),
360            params=self.base_param,
361            headers=self.header,
362        )
363        if not self.__is_valid_response(response):
364            return None
365        response_dict = response.json()
366        if not response_dict["success"]:
367            logger.error("Failed to get hole, response: %s", response_dict)
368            return None
369        return Hole.from_data(response_dict["data"])
370
371    async def get_hole_async(self, pid: Union[int, str]) -> Optional[Hole]:
372        """
373        异步获取单个树洞
374
375        Parameters
376        ----------
377        - pid: 树洞 ID
378
379        Returns
380        -------
381        1. 树洞，请求错误则返回 `None`
382        """
383
384        if not self.__is_num(pid):
385            raise ValueError("pid must be an integer or string of interger")
386        async with aiohttp.request(
387            "GET",
388            urljoin(self.hole_url, str(pid)),
389            params=self.base_param,
390            headers=self.header,
391        ) as response:
392            if not self.__is_valid_client_response(response):
393                return None
394            response_dict = await response.json()
395            if not response_dict["success"]:
396                logger.error("Failed to get hole, response: %s", response_dict)
397                return None
398            return Hole.from_data(response_dict["data"])
399
400    def get_holes(
401        self, page: Union[int, str] = 1, page_size: Union[int, str] = 25
402    ) -> Optional[List[Hole]]:
403        """
404        获取首页树洞
405
406        Parameters
407        ----------
408        - page: 列表页码，默认为 1
409        - page_size: 每页数量，默认为 25
410
411        Returns
412        -------
413        1. 首页树洞列表，请求错误则返回 `None`
414        """
415
416        if not self.__is_num(page):
417            raise ValueError("page must be an integer or string of interger")
418        if not self.__is_num(page_size):
419            raise ValueError("page_size must be an integer or string of interger")
420        param = {
421            **self.base_param,
422            **{"page": str(page), "limit": str(page_size)},
423        }
424        response = requests.get(self.holes_url, params=param, headers=self.header)
425        if not self.__is_valid_response(response):
426            return None
427        response_dict = response.json()
428        if not response_dict["success"]:
429            logger.error("Failed to get hole list, response: %s", response_dict)
430            return None
431        return list(map(Hole.from_data, response_dict["data"]["data"]))
432
433    async def get_holes_async(
434        self, page: Union[int, str] = 1, page_size: Union[int, str] = 25
435    ) -> Optional[List[Hole]]:
436        """
437        异步获取首页树洞
438
439        Parameters
440        ----------
441        - page: 列表页码，默认为 1
442        - page_size: 每页数量，默认为 25
443
444        Returns
445        -------
446        1. 首页树洞列表，请求错误则返回 `None`
447        """
448
449        if not self.__is_num(page):
450            raise ValueError("page must be an integer or string of interger")
451        if not self.__is_num(page_size):
452            raise ValueError("page_size must be an integer or string of interger")
453        param = {
454            **self.base_param,
455            **{"page": str(page), "limit": str(page_size)},
456        }
457        async with aiohttp.request(
458            "GET", self.holes_url, params=param, headers=self.header
459        ) as response:
460            if not self.__is_valid_client_response(response):
461                return None
462            response_dict = await response.json()
463            if not response_dict["success"]:
464                logger.error("Failed to get hole list, response: %s", response_dict)
465                return None
466            return list(map(Hole.from_data, response_dict["data"]["data"]))
467
468    def get_followed(
469        self, page: Union[int, str] = 1, page_size: Union[int, str] = 25
470    ) -> Optional[List[Hole]]:
471        """
472        获取关注树洞
473
474        Parameters
475        ----------
476        - page: 列表页码，默认为 1
477        - page_size: 每页数量，默认为 25
478
479        Returns
480        -------
481        1. 关注树洞列表，请求错误则返回 `None`
482        """
483
484        if not self.__is_num(page):
485            raise ValueError("page must be an integer or string of interger")
486        if not self.__is_num(page_size):
487            raise ValueError("page_size must be an integer or string of interger")
488        param = {
489            **self.base_param,
490            **{"page": str(page), "limit": str(page_size)},
491        }
492        response = requests.get(self.follow_url, params=param, headers=self.header)
493        if not self.__is_valid_response(response):
494            return None
495        response_dict = response.json()
496        if not response_dict["success"]:
497            logger.error(
498                "Failed to get followed hole list, response: %s", response_dict
499            )
500            return None
501        return list(map(Hole.from_data, response_dict["data"]["data"]))
502
503    async def get_followed_async(
504        self, page: Union[int, str] = 1, page_size: Union[int, str] = 25
505    ) -> Optional[List[Hole]]:
506        """
507        异步获取关注树洞
508
509        Parameters
510        ----------
511        - page: 列表页码，默认为 1
512        - page_size: 每页数量，默认为 25
513
514        Returns
515        -------
516        1. 关注树洞列表，请求错误则返回 `None`
517        """
518
519        if not self.__is_num(page):
520            raise ValueError("page must be an integer or string of interger")
521        if not self.__is_num(page_size):
522            raise ValueError("page_size must be an integer or string of interger")
523        param = {
524            **self.base_param,
525            **{"page": str(page), "limit": str(page_size)},
526        }
527        async with aiohttp.request(
528            "GET", self.follow_url, params=param, headers=self.header
529        ) as response:
530            if not self.__is_valid_client_response(response):
531                return None
532            response_dict = await response.json()
533            if not response_dict["success"]:
534                logger.error(
535                    "Failed to get followed hole list, response: %s", response_dict
536                )
537                return None
538            return list(map(Hole.from_data, response_dict["data"]["data"]))
539
540    def get_search(
541        self,
542        keywords: Union[str, List[str]],
543        page: Union[int, str] = 1,
544        page_size: Union[int, str] = 50,
545    ) -> Optional[List[Hole]]:
546        """
547        搜索树洞
548
549        Parameters
550        ----------
551        - keywords: 搜索关键词
552        - page: 列表页码，默认为 1
553        - page_size: 每页数量，默认为 50
554
555        Returns
556        -------
557        1. 搜索结果，请求错误则返回 `None`
558        """
559        if not self.__is_num(page):
560            raise ValueError("page must be an integer or string of interger")
561        if not self.__is_num(page_size):
562            raise ValueError("page size must be an integer or string of interger")
563        if isinstance(keywords, str):
564            keywords = [keywords]
565        param = {
566            **self.base_param,
567            **{
568                "page": str(page),
569                "limit": str(page_size),
570                "keyword": " ".join(keywords),
571            },
572        }
573        response = requests.get(self.holes_url, params=param, headers=self.header)
574        if not self.__is_valid_response(response):
575            return None
576        response_dict = response.json()
577        if not response_dict["success"]:
578            logger.error("Failed to get search result, response: %s", response_dict)
579            return None
580        return list(map(Hole.from_data, response_dict["data"]["data"]))
581
582    async def get_search_async(
583        self,
584        keywords: Union[str, List[str]],
585        page: Union[int, str] = 1,
586        page_size: Union[int, str] = 50,
587    ) -> Optional[List[Hole]]:
588        """
589        异步搜索树洞
590
591        Parameters
592        ----------
593        - keywords: 搜索关键词
594        - page: 列表页码，默认为 1
595        - page_size: 每页数量，默认为 50
596
597        Returns
598        -------
599        1. 搜索结果，请求错误则返回 `None`
600        """
601        if not self.__is_num(page):
602            raise ValueError("page must be an integer or string of interger")
603        if not self.__is_num(page_size):
604            raise ValueError("page size must be an integer or string of interger")
605        if isinstance(keywords, str):
606            keywords = [keywords]
607        param = {
608            **self.base_param,
609            **{
610                "page": str(page),
611                "limit": str(page_size),
612                "keyword": " ".join(keywords),
613            },
614        }
615        async with aiohttp.request(
616            "GET", self.holes_url, params=param, headers=self.header
617        ) as response:
618            if not self.__is_valid_client_response(response):
619                return None
620            response_dict = await response.json()
621            if not response_dict["success"]:
622                logger.error("Failed to get search result, response: %s", response_dict)
623                return None
624            return list(map(Hole.from_data, response_dict["data"]["data"]))
625
626    def post_hole(
627        self, text: str = "", image: Optional[Union[bytes, str]] = None
628    ) -> Optional[bool]:
629        """
630        发布树洞
631
632        Parameters
633        ----------
634        - text: 树洞内容
635        - image: 树洞图片 (二进制数据或文件名)
636
637        Returns
638        -------
639        1. 是否发布成功，请求错误则返回 `None`
640        """
641        if not text and not image:
642            raise EmptyError("Empty post is not allowed")
643        if image is not None:
644            if isinstance(image, str):
645                try:
646                    image = open(image, "rb").read()
647                except FileNotFoundError:
648                    logger.error(f"File {image} not found")
649                    raise FileNotFoundError("File not found")
650                except Exception as e:
651                    logger.error(f"Unknown error: {e}")
652                    raise e
653            # load for posting hole with image
654            load = {
655                "text": text,
656                "type": "image",
657            }
658            file = {"data": image}
659        else:
660            load = {
661                "text": text,
662                "type": "text",
663            }
664            file = {}
665        response = requests.post(
666            self.store_url,
667            params=self.base_param,
668            headers=self.header,
669            data=load,
670            files=file,
671        )
672        if not self.__is_valid_response(response):
673            return None
674        response_dict = response.json()
675        if not response_dict["success"]:
676            logger.exception("Post failed: %s", response_dict["messsage"])
677        return response_dict["success"]
678
679    async def post_hole_async(
680        self, text: str = "", image: Optional[Union[bytes, str]] = None
681    ) -> Optional[bool]:
682        """
683        异步发布树洞
684
685        Parameters
686        ----------
687        - text: 树洞内容
688        - image: 树洞图片 (二进制数据或文件名)
689
690        Returns
691        -------
692        1. 是否发布成功，请求错误则返回 `None`
693        """
694        if not text and not image:
695            raise EmptyError("Empty post is not allowed")
696        if image is not None:
697            if isinstance(image, str):
698                try:
699                    async with aiofiles.open(image, "rb") as f:
700                        image = await f.read()
701                except FileNotFoundError:
702                    logger.error(f"File {image} not found")
703                    raise FileNotFoundError("File not found")
704                except Exception as e:
705                    logger.error(f"Unknown error: {e}")
706                    raise e
707            # load for posting hole with image
708            load = {
709                "text": text,
710                "type": "image",
711                "data": image,
712            }
713        else:
714            load = {
715                "text": text,
716                "type": "text",
717            }
718        async with aiohttp.request(
719            "POST",
720            self.store_url,
721            params=self.base_param,
722            headers=self.header,
723            data=load,
724        ) as response:
725            if not self.__is_valid_client_response(response):
726                return None
727            response_dict = await response.json()
728            if not response_dict["success"]:
729                logger.exception("Post failed: %s", response_dict["messsage"])
730            return response_dict["success"]
731
732    def post_comment(
733        self,
734        pid: Union[int, str],
735        text: str,
736        reply_to: Optional[Union[int, str]] = None,
737    ) -> Optional[bool]:
738        """
739        发布评论
740
741        Parameters
742        ----------
743        - pid: 树洞 ID
744        - text: 评论内容
745        - reply_to: 回复的用户昵称或标号（非层号），`None` 为回复洞主（默认）
746
747        Returns
748        -------
749        1. 回复是否成功，请求错误则返回 `None`
750        """
751        if not text:
752            raise EmptyError("Empty post is not allowed")
753        if not self.__is_num(pid):
754            raise ValueError("pid must be an integer or string of interger")
755        if reply_to is not None:
756            if isinstance(reply_to, str):
757                assert reply_to in UserName, "Invalid reply_to"
758                reply_to = " ".join([x.capitalize() for x in reply_to.split()])
759            else:
760                reply_to = UserName[reply_to]
761            text = f"Re {reply_to}: {text}"
762        load = {
763            "pid": str(pid),
764            "text": text,
765        }
766        response = requests.post(
767            self.comment_url, params=self.base_param, headers=self.header, data=load
768        )
769        if not self.__is_valid_response(response):
770            return None
771        response_dict = response.json()
772        if not response_dict["success"]:
773            logger.exception("Comment failed: %s", response_dict["messsage"])
774        return response_dict["success"]
775
776    async def post_comment_async(
777        self,
778        pid: Union[int, str],
779        text: str,
780        reply_to: Optional[Union[int, str]] = None,
781    ) -> Optional[bool]:
782        """
783        异步发布评论
784
785        Parameters
786        ----------
787        - pid: 树洞 ID
788        - text: 评论内容
789        - reply_to: 回复的用户昵称或标号（非层号），`None` 为回复洞主（默认）
790
791        Returns
792        -------
793        1. 回复是否成功，请求错误则返回 `None`
794        """
795        if not text:
796            raise EmptyError("Empty post is not allowed")
797        if not self.__is_num(pid):
798            raise ValueError("pid must be an integer or string of interger")
799        if reply_to is not None:
800            if isinstance(reply_to, str):
801                assert reply_to in UserName, "Invalid reply_to"
802                reply_to = " ".join([x.capitalize() for x in reply_to.split()])
803            else:
804                reply_to = UserName[reply_to]
805            text = f"Re {reply_to}: {text}"
806        load = {
807            "pid": str(pid),
808            "text": text,
809        }
810        async with aiohttp.request(
811            "POST",
812            self.comment_url,
813            params=self.base_param,
814            headers=self.header,
815            data=load,
816        ) as response:
817            if not self.__is_valid_client_response(response):
818                return None
819            response_dict = await response.json()
820            if not response_dict["success"]:
821                logger.exception("Comment failed: %s", response_dict["messsage"])
822            return response_dict["success"]
823
824    def post_toggle_followed(
825        self, pid: Union[int, str], two_factor: bool = False
826    ) -> Union[Tuple[bool, int], Tuple[None, None]]:
827        """
828        切换关注状态
829
830        Parameters
831        ----------
832        - pid: 树洞 ID
833        - two_factor: 是否启用双重验证（默认为 `False`）
834
835        Returns
836        -------
837        1. 是否成功切换关注状态，请求错误则返回 `None`
838        2. 当前关注状态，`1` 为关注，`0` 为未关注，请求错误则返回 `None`
839        """
840        hole = self.get_hole(pid)
841        if hole is None or hole.is_follow is None:
842            logger.exception("Failed to get attention status of pid %s", pid)
843            return (None, None)
844        response = requests.post(
845            urljoin(self.attention_url, str(pid)),
846            params=self.base_param,
847            headers=self.header,
848        )
849        if not self.__is_valid_response(response):
850            return (None, None)
851        response_dict = response.json()
852        if not response_dict["success"]:
853            logger.exception("Toggle attention failed: %s", response_dict["messsage"])
854        if not two_factor:
855            return (
856                response_dict["success"],
857                (1 - hole.is_follow) if response_dict["success"] else hole.is_follow,
858            )
859        hole_verify = self.get_hole(pid)
860        if hole_verify is None or hole_verify.is_follow is None:
861            logger.exception("Failed to get attention status of pid %s", pid)
862            return (
863                response_dict["success"],
864                (1 - hole.is_follow) if response_dict["success"] else hole.is_follow,
865            )
866        return response_dict["success"], hole.is_follow
867
868    async def post_toggle_followed_async(
869        self, pid: Union[int, str], two_factor: bool = False
870    ) -> Union[Tuple[bool, int], Tuple[None, None]]:
871        """
872        异步切换关注状态
873
874        Parameters
875        ----------
876        - pid: 树洞 ID
877        - two_factor: 是否启用双重验证（默认为 `False`）
878
879        Returns
880        -------
881        1. 是否成功切换关注状态，请求错误则返回 `None`
882        2. 当前关注状态，`1` 为关注，`0` 为未关注，请求错误则返回 `None`
883        """
884        hole = await self.get_hole_async(pid)
885        if hole is None or hole.is_follow is None:
886            logger.exception("Failed to get attention status of pid %s", pid)
887            return (None, None)
888        async with aiohttp.request(
889            "POST",
890            urljoin(self.attention_url, str(pid)),
891            params=self.base_param,
892            headers=self.header,
893        ) as response:
894            if not self.__is_valid_client_response(response):
895                return (None, None)
896            response_dict = await response.json()
897            if not response_dict["success"]:
898                logger.exception(
899                    "Toggle attention failed: %s", response_dict["messsage"]
900                )
901            if not two_factor:
902                return (
903                    response_dict["success"],
904                    (1 - hole.is_follow)
905                    if response_dict["success"]
906                    else hole.is_follow,
907                )
908            hole_verify = await self.get_hole_async(pid)
909            if hole_verify is None or hole_verify.is_follow is None:
910                logger.exception("Failed to get attention status of pid %s", pid)
911                return (
912                    response_dict["success"],
913                    (1 - hole.is_follow)
914                    if response_dict["success"]
915                    else hole.is_follow,
916                )
917            return response_dict["success"], hole.is_follow
918
919    def post_report(self, pid: Union[int, str], reason: str = "") -> Optional[bool]:
920        """
921        举报树洞（注意！举报自己的树洞会导致立刻被删并且禁言）
922
923        Parameters
924        ----------
925        - pid: 树洞 ID
926        - reason: 举报理由（默认为空）
927
928        Returns
929        -------
930        1. 是否举报成功，请求错误则返回 `None`
931        """
932        if not self.__is_num(pid):
933            raise ValueError("pid must be an integer or string of interger")
934        load = {"reason": reason}
935        response = requests.post(
936            urljoin(self.report_url, str(pid)),
937            params=self.base_param,
938            headers=self.header,
939            data=load,
940        )
941        if not self.__is_valid_response(response):
942            return None
943        response_dict = response.json()
944        if not response_dict["success"]:
945            logger.exception("Report failed: %s", response_dict["messsage"])
946        return response_dict["success"]
947
948    async def post_report_async(
949        self, pid: Union[int, str], reason: str = ""
950    ) -> Optional[bool]:
951        """
952        异步举报树洞（注意！举报自己的树洞会导致立刻被删并且禁言）
953
954        Parameters
955        ----------
956        - pid: 树洞 ID
957        - reason: 举报理由（默认为空）
958
959        Returns
960        -------
961        1. 是否举报成功，请求错误则返回 `None`
962        """
963        if not self.__is_num(pid):
964            raise ValueError("pid must be an integer or string of interger")
965        load = {"reason": reason}
966        async with aiohttp.request(
967            "POST",
968            urljoin(self.report_url, str(pid)),
969            params=self.base_param,
970            headers=self.header,
971            data=load,
972        ) as response:
973            if not self.__is_valid_client_response(response):
974                return None
975            response_dict = await response.json()
976            if not response_dict["success"]:
977                logger.exception("Report failed: %s", response_dict["messsage"])
978            return response_dict["success"]