得物森林.py

类型 PY 下载 58 上传 2026-09-23 11:57:42 1160 行
得物森林

下载脚本

源码预览

完整 1160 行
得物森林.py 1160 lines
1# -*- coding=UTF-8 -*-
2# 当前脚本来自于 https://qljb.qianmyun.cn/ 脚本库下载!
3# 脚本库官方QQ群1群: 1042784482
4# 脚本库官方QQ群2群: 634010021
5# 脚本库官方QQ群3群: 736225093
6# 脚本库中的所有脚本文件均来自热心网友上传和互联网收集。
7# 脚本库仅提供文件上传和下载服务,不提供脚本文件的审核。
8# 您在使用脚本库下载的脚本时自行检查判断风险。
9# 所涉及到的 账号安全、数据泄露、设备故障、软件违规封禁、财产损失等...均由开发者、上传者、使用者自行承担。
10
11# const $ = new Env('得物森林')
12# cron "1 8,10,12,15,18,22 * * *"
13"""
14配置环境变量:
15dw_x_auth_token:Bearer xxxxxxxxxxxx   (多个账号用&分割),
16dw_sk: xxxxxxxxxxxxxxxxxxxxxxxxxxxx   (多个账号用&分割)
17如果运行存在问题 最好改一下User-Agent
18获取这两个变量的方法就是随便抓一个包含app.dewu.com/hacking-tree的URL,请求头里面的x-auth-token和SK
19
201、浇水充满气泡 存在bug
212、领取品牌特惠活动奖励存在bug
223、获取助力码存在bug
23"""
24import asyncio
25import random
26import re
27import time
28from datetime import datetime
29
30import httpx
31from urllib.parse import urlparse, parse_qs
32from fn_print import fn_print
33from get_env import get_env
34from sendNotify import send_notification_message_collection
35
36
37dw_x_auth_tokens = get_env("dw_x_auth_token", "&")
38dw_sks = get_env("dw_sk", "&")
39
40share_code_list = []
41HELP_SIGNAL = True  # 是否助力
42
43
44class DeWu:
45    WATERTING_G: int = 40  # 每次浇水克数
46    REMAINING_G: int = 1800  # 最后浇水剩余不超过的克数
47
48    def __init__(self, x_auth_token, index, sk, waterting_g=WATERTING_G, remaining_g=REMAINING_G):
49        self.client = httpx.AsyncClient(verify=False, timeout=60)
50        self.index = index
51        self.waterting_g = waterting_g
52        self.remaining_g = remaining_g
53        self.headers = {'appVersion': "5.55.0",
54                        'User-Agent': "Mozilla/5.0 (Linux; Android 15; PJZ110 Build/AP3A.240617.008; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/129.0.6668.70 Mobile Safari/537.36/duapp/5.55.0(android;15)",
55                        'x-auth-token': x_auth_token,
56                        'uuid': '0000000000000000',
57                        'SK': sk, }
58        self.user_name = None
59        self.tree_id = 0  # 树的id
60        self.tasks_completed_number = 0  # 任务完成数
61        self.cumulative_task_list = []  # 累计计任务列表
62        self.tasks_dict_list = []  # 任务字典列表
63        self.is_team_tree = False  # 是否是团队树
64
65    @staticmethod
66    def get_url_key_value(url, key):
67        parsed_url = urlparse(url)
68        query_params = parse_qs(parsed_url.query)
69        _dict = {k: v[0] if len(v) == 1 else v for k, v in query_params.items()}
70        key_value = _dict.get(key)
71        return key_value
72
73    async def get_user_info(self):
74        """
75        获取用户信息
76        :return: 
77        """
78        user_info_response = await self.client.get(url="https://app.dewu.com/hacking-tree/v1/team/info",
79                                                   headers=self.headers)
80        if user_info_response.status_code == 200:
81            user_info_data = user_info_response.json()
82            if user_info_data['code'] == 200:
83                self.user_name = user_info_data.get("data").get("member")[0].get("name")
84            else:
85                fn_print(f"===获取用户信息失败❌, {user_info_data.get('msg')}===")
86        else:
87            fn_print(f"===获取用户信息请求异常❌, {user_info_response.status_code}===")
88
89    async def tree_info(self):
90        url = "https://app.dewu.com/hacking-tree/v1/user/target/info"
91        tree_info_response = await self.client.get(url=url, headers=self.headers)
92        if tree_info_response.status_code == 200:
93            tree_info_data = tree_info_response.json()
94            if tree_info_data['code'] == 200:
95                name = tree_info_data.get("data").get("name")
96                level = tree_info_data.get("data").get("level")
97                fn_print(f"用户【{self.user_name}】,===目标奖品🥇:{name}, 当前小树等级:{level}===")
98                return name, level
99            fn_print(f"用户【{self.user_name}】,===获取许愿树信息失败❌, {tree_info_data.get('msg')}===")
100        else:
101            fn_print(f"用户【{self.user_name}】,===获取许愿树信息请求异常❌, {tree_info_response.status_code}===")
102
103    async def determine_whether_is_team_tree(self):
104        """
105        获取是否是团队树
106        :return: 
107        """
108        team_tree_response = await self.client.get(
109            url="https://app.dewu.com/hacking-tree/v1/team/info",
110            headers=self.headers
111        )
112        if team_tree_response.status_code == 200:
113            team_tree_data = team_tree_response.json()
114            if team_tree_data.get("data").get("show") and team_tree_data.get("data").get("teamTreeId"):
115                self.is_team_tree = True
116        else:
117            fn_print(f"用户【{self.user_name}】,===获取是否团队树请求异常❌, {team_tree_response.status_code}===")
118
119    async def sign_in(self):
120        """
121        签到
122        :return: 
123        """
124        sign_in_response = await self.client.post(
125            url="https://app.dewu.com/hacking-game-center/v1/sign/sign",
126            headers=self.headers
127        )
128        if sign_in_response.status_code == 200:
129            sign_in_data = sign_in_response.json()
130            if sign_in_data.get("code") == 200:
131                fn_print(f"用户【{self.user_name}】,===签到成功✅✅===")
132            else:
133                fn_print(f"用户【{self.user_name}】,===签到失败❌, {sign_in_data.get('msg')}===")
134        else:
135            fn_print(f"用户【{self.user_name}】,===签到发生异常❌, {sign_in_response.status_code}===")
136
137    async def droplet_sign_in(self):
138        """
139        水滴签到
140        :return: 
141        """
142        droplet_sign_in_response = await self.client.post(
143            url="https://app.dewu.com/hacking-tree/v1/sign/sign_in",
144            headers=self.headers
145        )
146        if droplet_sign_in_response.status_code == 200:
147            droplet_sign_in_data = droplet_sign_in_response.json()
148            if droplet_sign_in_data.get("code") == 200:
149                fn_print(
150                    f"用户【{self.user_name}】,===水滴签到成功✅✅, 获得{droplet_sign_in_data.get('data').get('Num')}g水滴💧💧💧===")
151            else:
152                fn_print(f"用户【{self.user_name}】,===水滴签到失败❌, {droplet_sign_in_data.get('msg')}===")
153        else:
154            fn_print(f"用户【{self.user_name}】,===水滴签到发生异常❌, {droplet_sign_in_response.status_code}===")
155
156    async def receive_droplet_extra(self):
157        """
158        领取气泡水滴
159        :return: 
160        """
161        flag = -1
162        countdown_time = 0
163        recevie_signal = False
164        for _ in range(50):
165            droplet_extra_response = await self.client.get(
166                url="https://app.dewu.com/hacking-tree/v1/droplet-extra/info",
167                headers=self.headers
168            )
169            if droplet_extra_response.status_code == 200:
170                droplet_extra_data = droplet_extra_response.json()
171                if droplet_extra_data.get("code") != 200:
172                    fn_print(f"用户【{self.user_name}】,===获取气泡水滴信息失败❌, {droplet_extra_data}===")
173                    return
174                data = droplet_extra_data.get("data")
175                receivable = data.get("receivable")
176                if receivable:
177                    if data.get("dailyExtra"):
178                        water_droplet_num = data.get("dailyExtra").get("totalDroplet")
179                    else:
180                        water_droplet_num = data.get("onlineExtra").get("totalDroplet")
181                    if flag == water_droplet_num or recevie_signal:
182                        fn_print(f"用户【{self.user_name}】,===当前可领取气泡水滴{water_droplet_num}g水滴💧===")
183                        receive_droplet_extra_response = await self.client.post(
184                            url="https://app.dewu.com/hacking-tree/v1/droplet-extra/receive",
185                            headers=self.headers
186                        )
187                        if receive_droplet_extra_response.status_code == 200:
188                            receive_droplet_extra_data = receive_droplet_extra_response.json()
189                            if receive_droplet_extra_data.get("code") != 200:
190                                countdown_time += 60
191                                if countdown_time > 60:
192                                    fn_print(
193                                        f"用户【{self.user_name}】,===领取气泡水滴失败❌, {receive_droplet_extra_data}===")
194                                    return
195                                fn_print(f"用户【{self.user_name}】,===等待{countdown_time}秒后领取===")
196                                await asyncio.sleep(countdown_time)
197                                continue
198                            fn_print(
199                                f"用户【{self.user_name}】,===领取气泡水滴成功✅✅, 获得{receive_droplet_extra_data.get('data').get('totalDroplet')}g水滴💧===")
200                            countdown_time = 0  # 重置时间
201                            continue
202                        else:
203                            fn_print(
204                                f"用户【{self.user_name}】,===领取气泡水滴发生异常❌, {receive_droplet_extra_response.status_code}===")
205                        flag = water_droplet_num
206                        recevie_signal = True
207                    flag = water_droplet_num
208                    fn_print(f"用户【{self.user_name}】,===当前气泡水滴{water_droplet_num}g, 未满,开始浇水===")
209                    if not await self.waterting():
210                        recevie_signal = True
211                    await asyncio.sleep(0.5)
212                    continue
213                water_droplet_num = droplet_extra_data.get("data").get("dailyExtra").get("totalDroplet")
214                fn_print(
215                    f"用户【{self.user_name}】,==={droplet_extra_data.get('data').get('dailyExtra').get('popTitle')}, "
216                    f"已经积攒{water_droplet_num}g水滴!===")
217            else:
218                fn_print(
219                    f"用户【{self.user_name}】,===获取气泡水滴信息发生异常❌, {droplet_extra_response.status_code}===")
220
221    async def waterting_droplet_extra(self):
222        """
223        浇水充满气泡水滴
224        :return: 
225        """
226        while True:
227            water_response = await self.client.get(
228                url="https://app.dewu.com/hacking-tree/v1/droplet-extra/info",
229                headers=self.headers
230            )
231            if water_response.status_code == 200:
232                water_data = water_response.json()
233                count = water_data.get("data").get("dailyExtra", {}).get("times", 0)
234                if not count:
235                    fn_print(
236                        f"用户【{self.user_name}】,===气泡水滴已充满,明日可领取{water_data.get('data').get('dailyExtra').get('totalDroplet')}g===")
237                    return
238                for _ in range(count):
239                    if not await self.waterting():
240                        return
241                    await asyncio.sleep(0.5)
242            else:
243                fn_print(f"用户【{self.user_name}】,===获取气泡水滴信息发生异常❌, {water_response.status_code}===")
244
245    async def receive_bucket_droplet(self):
246        """
247        领取木桶水滴,200秒满一次,每天领取3次
248        :return: 
249        """
250        receive_bucket_droplet_response = await self.client.post(
251            url="https://app.dewu.com/hacking-tree/v1/droplet/get_generate_droplet",
252            headers=self.headers
253        )
254        if receive_bucket_droplet_response.status_code == 200:
255            receive_bucket_droplet_data = receive_bucket_droplet_response.json()
256            if receive_bucket_droplet_data.get("code") != 200:
257                fn_print(
258                    f"用户【{self.user_name}】,===领取木桶水滴失败❌, {receive_bucket_droplet_data}===")
259                return
260            fn_print(
261                f"用户【{self.user_name}】,===领取木桶水滴成功✅✅, 获得{receive_bucket_droplet_data.get('data').get('droplet')}g水滴💧===")
262        else:
263            fn_print(
264                f"用户【{self.user_name}】,===领取木桶水滴发生异常❌, {receive_bucket_droplet_response.status_code}===")
265
266    async def judging_bucket_droplet(self):
267        """
268        判断木桶水滴是否可以领取
269        :return: 
270        """
271        judging_bucket_droplet_response = await self.client.get(
272            url="https://app.dewu.com/hacking-tree/v1/droplet/generate_info",
273            headers=self.headers
274        )
275        if judging_bucket_droplet_response.status_code == 200:
276            judging_bucket_droplet_data = judging_bucket_droplet_response.json()
277            if judging_bucket_droplet_data.get("data").get("currentDroplet") == 100:
278                fn_print(
279                    f"用户【{self.user_name}】,===今天已领取木桶水滴{judging_bucket_droplet_data.get('data').get('getTimes')}次===")
280                await self.receive_bucket_droplet()
281                return True
282            return False
283        else:
284            fn_print(
285                f"用户【{self.user_name}】,===判断木桶水滴发生异常❌, {judging_bucket_droplet_response.status_code}===")
286
287    async def get_shared_code(self):
288        """
289        获取助力码
290        :return: 
291        """
292        get_shared_code_response = await self.client.post(
293            url="https://app.dewu.com/hacking-tree/v1/keyword/gen",
294            headers=self.headers
295        )
296        if get_shared_code_response.status_code == 200:
297            get_shared_code_data = get_shared_code_response.json()
298            if get_shared_code_data.get("code") != 200:
299                fn_print(
300                    f"用户【{self.user_name}】,===获取助力码失败❌, {get_shared_code_data}===")
301                return
302            share_code = get_shared_code_data.get("data").get("keywordDesc").replace("\n", "")
303            fn_print(f"用户【{self.user_name}】,===获取助力码 {share_code} 成功✅✅===")
304        else:
305            fn_print(
306                f"用户【{self.user_name}】,===获取助力码发生异常❌, {get_shared_code_response.status_code}===")
307
308    async def get_droplet_number(self):
309        """
310        获取水滴数
311        :return: 
312        """
313        headers = self.headers
314        headers.update(
315            {
316                'channel': 'opp',
317                'uuid': '0000000000000000',
318                'isProxy': "0",
319                'emu': "0",
320                'isRoot': "0",
321                'deviceTrait': "PJZ110",
322                'ua': "duapp/5.55.0(android;15)",
323                'Origin': "https://cdn-m.dewu.com",
324                'X-Requested-With': "com.shizhuang.duapp",
325                'Sec-Fetch-Site': "same-site",
326                'Sec-Fetch-Mode': "cors",
327                'Sec-Fetch-Dest': "empty",
328                'Referer': "https://cdn-m.dewu.com/",
329                'Accept-Language': "zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7",
330            }
331        )
332        get_droplet_number_response = await self.client.post(
333            url="https://app.dewu.com/hacking-tree/v1/user/init",
334            headers=headers,
335            json={"keyword": ""}
336        )
337        if get_droplet_number_response.status_code == 200:
338            get_droplet_number_data = get_droplet_number_response.json()
339            data = get_droplet_number_data.get("data")
340            if data:
341                droplet_number = data.get("droplet")
342                return droplet_number
343            else:
344                fn_print(f"用户【{self.user_name}】,===获取水滴数失败❌, {get_droplet_number_data}===")
345        else:
346            fn_print(f"用户【{self.user_name}】,===获取水滴数发生异常❌, {get_droplet_number_response.status_code}===")
347
348    async def receive_cumulative_tasks_reward(self, condition):
349        """
350        领取累计任务奖励
351        :return: 
352        """
353        recevie_cumulative_tasks_reward_response = await self.client.post(
354            url="https://app.dewu.com/hacking-tree/v1/task/extra",
355            headers=self.headers,
356            json={"condition": condition}
357        )
358        if recevie_cumulative_tasks_reward_response.status_code == 200:
359            recevie_cumulative_tasks_reward_data = recevie_cumulative_tasks_reward_response.json()
360            if recevie_cumulative_tasks_reward_data.get("code") != 200:
361                fn_print(
362                    f"用户【{self.user_name}】,===领取累计任务奖励失败❌, {recevie_cumulative_tasks_reward_data}===")
363                return
364            fn_print(
365                f"用户【{self.user_name}】,===领取累计任务奖励成功✅✅, 获得{recevie_cumulative_tasks_reward_data.get('data').get('num')}g水滴💧===")
366        else:
367            fn_print(
368                f"用户【{self.user_name}】,===领取累计任务奖励发生异常❌, {recevie_cumulative_tasks_reward_response.status_code}===")
369
370    async def receive_task_reward(self, classify, task_id, task_type):
371        """
372        领取任务奖励
373        :param classify: 
374        :param task_id: 
375        :param task_type: 
376        :return: 
377        """
378        await asyncio.sleep(0.2)
379        url = "https://app.dewu.com/hacking-tree/v1/task/receive"
380        if task_type in [251]:
381            json = {'classify': classify, 'taskId': task_id, 'completeFlag': 1}
382        else:
383            json = {'classify': classify, 'taskId': task_id}
384        recevie_task_reward_response = await self.client.post(
385            url=url,
386            headers=self.headers,
387            json=json
388        )
389        if recevie_task_reward_response.status_code == 200:
390            recevie_task_reward_data = recevie_task_reward_response.json()
391            if recevie_task_reward_data.get("code") != 200:
392                fn_print(
393                    f"用户【{self.user_name}】,===领取任务奖励失败❌, {recevie_task_reward_data}===")
394                return
395            fn_print(
396                f"用户【{self.user_name}】,===领取任务奖励成功✅✅, 获得{recevie_task_reward_data.get('data').get('num')}g水滴💧===")
397        else:
398            fn_print(
399                f"用户【{self.user_name}】,===领取任务奖励发生异常❌, {recevie_task_reward_response.status_code}===")
400
401    async def receive_watering_reward(self):
402        """
403        领取浇水奖励
404        :return: 
405        """
406        recevie_watering_reward_response = await self.client.post(
407            url="https://app.dewu.com/hacking-tree/v1/tree/get_watering_reward",
408            headers=self.headers,
409            json={"promote": ""}
410        )
411        if recevie_watering_reward_response.status_code == 200:
412            recevie_watering_reward_data = recevie_watering_reward_response.json()
413            if recevie_watering_reward_data.get("code") != 200:
414                fn_print(
415                    f"用户【{self.user_name}】,===领取浇水奖励失败❌, {recevie_watering_reward_data}===")
416                return
417            fn_print(
418                f"用户【{self.user_name}】,===领取浇水奖励成功✅✅, 获得{recevie_watering_reward_data.get('data').get('currentWateringReward').get('rewardNum')}g水滴💧===")
419        else:
420            fn_print(
421                f"用户【{self.user_name}】,===领取浇水奖励发生异常❌, {recevie_watering_reward_response.status_code}===")
422
423    async def receive_level_reward(self):
424        """
425        领取等级奖励
426        :return: 
427        """
428        for _ in range(20):
429            recevie_level_reward_response = await self.client.post(
430                url="https://app.dewu.com/hacking-tree/v1/tree/get_level_reward",
431                headers=self.headers,
432                json={"promote": ""}
433            )
434            if recevie_level_reward_response.status_code == 200:
435                recevie_level_reward_data = recevie_level_reward_response.json()
436                if recevie_level_reward_data.get("code") != 200 or recevie_level_reward_data.get("data") is None:
437                    fn_print(
438                        f"用户【{self.user_name}】,===领取等级奖励失败❌, {recevie_level_reward_data.get('msg')}===")
439                    return
440                level = recevie_level_reward_data.get("data").get("levelReward").get("showLevel") - 1
441                reward_num = recevie_level_reward_data.get("data").get("currentLevelReward").get("rewardNum")
442                fn_print(
443                    f"用户【{self.user_name}】,===领取{level}级奖励成功✅✅, 获得{reward_num}g水滴💧===")
444                if not recevie_level_reward_data.get("data").get("levelReward").get("isComplete"):
445                    return
446                await asyncio.sleep(1)
447            else:
448                fn_print(
449                    f"用户【{self.user_name}】,===领取等级奖励发生异常❌, {recevie_level_reward_response.status_code}===")
450
451    async def execute_receive_watering_reward(self):
452        """
453        多次执行浇水,领取浇水奖励
454        :return: 
455        """
456        for _ in range(20):
457            execute_receive_watering_reward_response = await self.client.get(
458                url="https://app.dewu.com/hacking-tree/v1/tree/get_tree_info",
459                headers=self.headers
460            )
461            if execute_receive_watering_reward_response.status_code == 200:
462                execute_receive_watering_reward_data = execute_receive_watering_reward_response.json()
463                if execute_receive_watering_reward_data.get("code") != 200:
464                    fn_print(f"用户【{self.user_name}】,===获取种树进度失败❌, {execute_receive_watering_reward_data}===")
465                    return
466                count = execute_receive_watering_reward_data.get("data").get("nextWateringTimes")
467                if execute_receive_watering_reward_data.get("data").get("wateringReward") is None or count <= 0:
468                    return
469                for _ in range(count):
470                    if not await self.waterting():
471                        return
472                    await asyncio.sleep(0.5)
473            else:
474                fn_print(
475                    f"用户【{self.user_name}】,===获取种树进度发生异常❌, {execute_receive_watering_reward_response.status_code}===")
476
477    async def waterting_until_less_than(self):
478        """
479        浇水直到小于指定克数
480        :return: 
481        """
482        droplet_number = await self.get_droplet_number()
483        if droplet_number > self.waterting_g:
484            count = int((droplet_number - self.remaining_g) / self.waterting_g)
485            for _ in range(count + 1):
486                if not await self.waterting():
487                    return
488                await asyncio.sleep(0.5)
489
490    async def submit_task_completion_status(self, json):
491        submit_task_completion_status_response = await self.client.post(
492            url="https://app.dewu.com/hacking-task/v1/task/commit",
493            headers=self.headers,
494            json=json
495        )
496        if submit_task_completion_status_response.status_code == 200:
497            submit_task_completion_status_data = submit_task_completion_status_response.json()
498            if submit_task_completion_status_data.get("code") == 200:
499                return True
500            return False
501        else:
502            fn_print(
503                f"用户【{self.user_name}】,===提交任务完成状态发生异常❌, {submit_task_completion_status_response.status_code}===")
504            return False
505
506    async def get_task_list(self):
507        """
508        获取任务列表
509        :return: 
510        """
511        get_task_list_response = await self.client.get(
512            url="https://app.dewu.com/hacking-tree/v1/task/list",
513            headers=self.headers
514        )
515        if get_task_list_response.status_code == 200:
516            get_task_list_data = get_task_list_response.json()
517            if get_task_list_data.get("code") == 200:
518                self.tasks_completed_number = get_task_list_data.get("data").get("userStep")  # 已完成任务数量
519                self.cumulative_task_list = get_task_list_data.get('data').get('extraAwardList')  # 累计任务列表            
520                self.tasks_dict_list = get_task_list_data.get('data').get('taskList')  # 任务列表
521                return True
522        else:
523            fn_print(f"用户【{self.user_name}】,===获取任务列表发生异常❌, {get_task_list_response.status_code}===")
524            return False
525
526    async def task_obtain(self, task_id, task_type):
527        """
528        水滴大放送任务
529        :param task_id: 
530        :param task_type: 
531        :return: 
532        """
533        task_obtain_response = await self.client.post(
534            url="https://app.dewu.com/hacking-task/v1/task/obtain",
535            headers=self.headers,
536            json={"taskId": task_id, "taskType": task_type}
537        )
538        if task_obtain_response.status_code == 200:
539            task_obtain_data = task_obtain_response.json()
540            if task_obtain_data.get("code") == 200 and task_obtain_data.get("status") == 200:
541                return True
542            return False
543        else:
544            fn_print(f"用户【{self.user_name}】,===水滴大放送任务步骤发生异常❌, {task_obtain_response.status_code}===")
545
546    async def task_commit_pre(self, json):
547        """
548        浏览任务
549        :param json: 
550        :return: 
551        """
552        task_commit_pre_response = await self.client.post(
553            url="https://app.dewu.com/hacking-task/v1/task/pre_commit",
554            headers=self.headers,
555            json=json
556        )
557        if task_commit_pre_response.status_code == 200:
558            task_commit_pre_data = task_commit_pre_response.json()
559            if task_commit_pre_data.get("code") == 200 and task_commit_pre_data.get("status") == 200:
560                return True
561            return False
562        else:
563            fn_print(f"用户【{self.user_name}】,===浏览任务发生异常❌, {task_commit_pre_response.status_code}===")
564
565    async def execute_task(self):
566        """
567        执行任务
568        :return: 
569        """
570        await self.get_task_list()
571        for task_dict in self.tasks_dict_list:
572            if task_dict.get("isReceiveReward"):    # 为True,这个任务奖励已经领取过了
573                continue
574            if task_dict.get("rewardCount") >= 3000:    # 奖励的水滴大于3000,需要下单,跳过
575                continue
576            classify = task_dict.get('classify')
577            task_id = task_dict.get('taskId')
578            task_type = task_dict.get('taskType')
579            task_name = task_dict.get('taskName')
580            btd = self.get_url_key_value(task_dict.get('jumpUrl'), 'btd')
581            btd = int(btd) if btd else 0
582            spu_id = self.get_url_key_value(task_dict.get('jumpUrl'), 'spuId')
583            spu_id = int(spu_id) if spu_id else 0
584            if task_dict.get("isComplete"):
585                if task_name == "领40g水滴值" and not task_dict.get("receivable"):
586                    continue
587                fn_print(f"用户【{self.user_name}】,===开始执行任务【{task_name}】===")
588                await self.receive_task_reward(classify, task_id, task_type)
589                continue
590            fn_print(f"用户【{self.user_name}】,===开始执行任务【{task_name}】===")
591            if task_name == "完成一次签到":
592                await self.sign_in()
593                json = {
594                    "taskId": task_dict.get("taskId"),
595                    "taskType": str(task_dict.get("taskType")),
596                }
597                if await self.submit_task_completion_status(json):
598                    await self.receive_task_reward(classify, task_id, task_type)
599                    continue
600            if task_name == "领40g水滴值":
601                await self.receive_task_reward(classify, task_id, task_type)
602                continue
603            if task_name == "收集一次水滴生产":
604                if await self.judging_bucket_droplet():
605                    await self.receive_task_reward(classify, task_id, task_type)
606                else:
607                    fn_print(f"用户【{self.user_name}】,===当前木桶水滴未达到100g,下次来完成任务吧!===")
608                continue
609            if task_name == "浏览【我】的右上角星愿森林入口":
610                report_action_response = await self.client.post(
611                    url="https://app.dewu.com/hacking-tree/v1/user/report_action",
612                    headers=self.headers,
613                    json={"action": task_id}
614                )
615                if report_action_response.status_code == 200:
616                    report_action_data = report_action_response.json()
617                    if report_action_data.get("code"):
618                        await self.receive_task_reward(classify, task_id, task_type)
619                    continue
620            if any(re.match(pattern, task_name) for pattern in
621                   ["参与1次上上签活动", "从桌面组件访问许愿树", "参与1次拆盲盒", "去.*"]):
622                await self.submit_task_completion_status(
623                    {
624                        "taskId": task_id,
625                        "taskType": int(task_type)
626                    }
627                )
628                await self.receive_task_reward(classify, task_id, task_type)
629                continue
630
631            if any(re.match(pattern, task_name) for pattern in [".*订阅.*", ".*逛一逛.*", "逛逛.*活动"]):
632                await self.submit_task_completion_status(
633                    {
634                        "taskId": task_id,
635                        "taskType": int(task_type),
636                        "btd": btd
637                    }
638                )
639                await self.receive_task_reward(classify, task_id, task_type)
640                continue
641            if any(re.match(pattern, task_name) for pattern in [".*逛逛.*", "浏览.*s"]):
642                if await self.task_commit_pre(
643                        {
644                            "taskId": task_id,
645                            "taskType": int(task_type),
646                            "btd": btd
647                        }
648                ):
649                    await asyncio.sleep(16)
650                    await self.submit_task_completion_status(
651                        {
652                            "taskId": task_id,
653                            "taskType": int(task_type),
654                            "activityType": None,
655                            "activityId": None,
656                            "taskSetId": None,
657                            "venueCode": None,
658                            "venueUnitStyle": None,
659                            "taskScene": None,
660                            "btd": btd
661                        }
662                    )
663                    await self.receive_task_reward(classify, task_id, task_type)
664                    continue
665            if any(re.match(pattern, task_name) for pattern in [".*晒图.*"]):
666                if await self.task_commit_pre(
667                        {
668                            "taskId": task_id,
669                            "taskType": int(task_type)
670                        }
671                ):
672                    await asyncio.sleep(16)
673                    await self.submit_task_completion_status(
674                        {
675                            "taskId": task_id,
676                            "taskType": int(task_type),
677                            "activityType": None,
678                            "activityId": None,
679                            "taskSetId": None,
680                            "venueCode": None,
681                            "venueUnitStyle": None,
682                            "taskScene": None
683                        }
684                    )
685                    await self.receive_task_reward(classify, task_id, task_type)
686                    continue
687            if task_name == "完成五次浇灌":
688                count = task_dict.get("total") - task_dict.get("curStep")
689                if await self.get_droplet_number() < (self.waterting_g * count):
690                    fn_print(f"用户【{self.user_name}】,===当前水滴不足以完成任务,下次来完成任务吧!===")
691                    continue
692                for _ in range(count):
693                    await asyncio.sleep(0.5)
694                    if not await self.waterting():
695                        break
696                else:
697                    if await self.submit_task_completion_status(
698                            {
699                                "taskId": task_dict.get("taskId"),
700                                "taskType": str(task_dict.get("taskType"))
701                            }
702                    ):
703                        await self.receive_task_reward(classify, task_id, task_type)
704                        continue
705            if any(re.match(pattern, task_name) for pattern in [".*专场", ".*水滴大放送"]):
706                if await self.task_obtain(task_id, task_type):
707                    if await self.task_commit_pre(
708                            {
709                                "taskId": task_id,
710                                "taskType": 16
711                            }
712                    ):
713                        await asyncio.sleep(16)
714                        await self.submit_task_completion_status(
715                            {
716                                "taskId": task_id,
717                                "taskType": int(task_type)
718                            }
719                        )
720                        await self.receive_task_reward(classify, task_id, task_type)
721                        continue
722            fn_print(f"该任务暂时无法处理,请提交日志给作者!{task_dict}")
723
724    async def execute_cumulative_task(self):
725        """
726        执行累计任务
727        :return: 
728        """
729        await self.get_task_list()
730        for task in self.cumulative_task_list:
731            if task.get("status") == 1:
732                fn_print(f"用户【{self.user_name}】,===开始领取累计任务数达{task.get('condition')}个的奖励===")
733                await self.receive_cumulative_tasks_reward(task.get("condition"))
734                await asyncio.sleep(1)
735
736    async def droplet_invest(self):
737        """
738        水滴投资
739        :return: 
740        """
741        droplet_invest_response = await self.client.get(
742            url="https://app.dewu.com/hacking-tree/v1/invest/info",
743            headers=self.headers
744        )
745        if droplet_invest_response.status_code == 200:
746            droplet_invest_data = droplet_invest_response.json()
747            if not droplet_invest_data.get("data").get("isToday"):
748                await self.receive_droplet_invest()
749            else:
750                fn_print(f"用户【{self.user_name}】,===今日已领取过水滴投资奖励了===")
751            await asyncio.sleep(2)
752            droplet_invest_response = await self.client.get(
753                url="https://app.dewu.com/hacking-tree/v1/invest/info",
754                headers=self.headers
755            )
756            droplet_invest_data = droplet_invest_response.json()
757            if droplet_invest_data.get("data").get("triggered"):
758                invest_commit_response = await self.client.post(
759                    url="https://app.dewu.com/hacking-tree/v1/invest/commit",
760                    headers=self.headers
761                )
762                invest_commit_data = invest_commit_response.json()
763                if invest_commit_data.get("code") == 200 and invest_commit_data.get("status") == 200:
764                    fn_print(f"用户【{self.user_name}】,===水滴投资成功✅✅, 水滴-100g===")
765                    return
766                if invest_commit_data.get("msg") == "水滴不够了":
767                    fn_print(f"用户【{self.user_name}】,===水滴投资失败❌, 水滴不够了。{invest_commit_data.get('msg')}===")
768                    return
769                fn_print(f"用户【{self.user_name}】,===水滴投资有问题❌, {invest_commit_data}===")
770                return
771            else:
772                fn_print(f"用户【{self.user_name}】,===今日已水滴投资过了===")
773        else:
774            fn_print(f"用户【{self.user_name}】,===水滴投资发生异常❌, {droplet_invest_response.status_code}===")
775
776    async def receive_droplet_invest(self):
777        """
778        领取水滴投资奖励
779        :return: 
780        """
781        receive_droplet_invest_response = await self.client.post(
782            url="https://app.dewu.com/hacking-tree/v1/invest/receive",
783            headers=self.headers
784        )
785        if receive_droplet_invest_response.status_code == 200:
786            receive_droplet_invest_data = receive_droplet_invest_response.json()
787            profit = receive_droplet_invest_data.get("data").get("profit")
788            fn_print(f"用户【{self.user_name}】,===领取水滴投资奖励成功✅✅,收益-{profit}g水滴💧===")
789        else:
790            fn_print(
791                f"用户【{self.user_name}】,===领取水滴投资奖励请求发生异常❌, {receive_droplet_invest_response.status_code}===")
792
793    async def get_share_code(self):
794        """
795        获取助力码
796        :return: 
797        """
798        get_share_code_response = await self.client.get(
799            url="https://app.dewu.com/hacking-tree/v1/keyword/gen",
800            headers=self.headers
801        )
802        if get_share_code_response.status_code == 200:
803            get_share_code_data = get_share_code_response.json()
804            if get_share_code_data.get("status") == 200:
805                keyword = get_share_code_data.get("data").get("keyword")
806                keyword = re.findall("œ(.*?)œ ", keyword)
807                if keyword:
808                    fn_print(f"用户【{self.user_name}】,===获取助力码成功✅✅, {keyword[0]}===")
809                    return keyword[0]
810            else:
811                fn_print(f"用户【{self.user_name}】,===获取助力码失败❌, {get_share_code_data}===")
812        else:
813            fn_print(f"用户【{self.user_name}】,===获取助力码发生异常❌, {get_share_code_response.status_code}===")
814
815    async def help_user(self):
816        """
817        助力
818        :return: 
819        """
820        if not HELP_SIGNAL:  # 未开启助力
821            return
822        url = "https://app.dewu.com/hacking-tree/v1/user/init"
823        if self.index == 0:
824            for share_code in share_code_list:
825                help_user_response = await self.client.post(
826                    url=url,
827                    headers=self.headers,
828                    json={"keyword": share_code}
829                )
830                if help_user_response.status_code == 200:
831                    help_user_data = help_user_response.json()
832                    data = help_user_data.get("data")
833                    if not data:
834                        continue
835                    invite_res = data.get("inviteRes")
836                    if any(re.match(pattern, invite_res) for pattern in ["助力成功", "助力失败", "今日已助力过了"]):
837                        fn_print(f"用户【{self.user_name}】,===开始助力{share_code}===", end=" ")
838                        fn_print(invite_res)
839                        return
840                    await asyncio.sleep(random.randint(20, 30) / 10)
841                else:
842                    fn_print(f"用户【{self.user_name}】,===助力发生异常❌, {help_user_response.status_code}===")
843        for share_code in share_code_list:
844            fn_print(f"用户【{self.user_name}】,===开始助力{share_code}===", end=" ")
845            help_user_response = await self.client.post(
846                url=url,
847                headers=self.headers,
848                json={"keyword": share_code}
849            )
850            if help_user_response.status_code == 200:
851                help_user_data = help_user_response.json()
852                data = help_user_data.get("data")
853                if not data:
854                    fn_print(f"用户【{self.user_name}】,===助力失败❌, {help_user_data}===")
855                invite_res = data.get("inviteRes")
856                fn_print(invite_res)
857                if any(re.match(pattern, invite_res) for pattern in ["助力成功", "助力失败", "今日已助力过了"]):
858                    return
859                await asyncio.sleep(random.randint(20, 30) / 10)
860            else:
861                fn_print(f"用户【{self.user_name}】,===助力发生异常❌, {help_user_response.status_code}===")
862        return
863
864    async def receive_help_reward(self):
865        """
866        领取助力奖励
867        :return: 
868        """
869        receive_help_reward_list_response = await self.client.get(
870            url="https://app.dewu.com/hacking-tree/v1/invite/list",
871            headers=self.headers
872        )
873        if receive_help_reward_list_response.status_code == 200:
874            receive_help_reward_list_data = receive_help_reward_list_response.json()
875            if receive_help_reward_list_data.get("status") == 200:
876                reward_list = receive_help_reward_list_data.get("data").get("list")
877                if not reward_list:
878                    return
879                for reward in reward_list:
880                    if reward.get("status") != 0:
881                        continue
882                    invitee_user_id = reward.get("inviteeUserId")
883                    receive_help_reward_response = await self.client.post(
884                        url="https://app.dewu.com/hacking-tree/v1/invite/reward",
885                        headers=self.headers,
886                        json={
887                            "inviteeUserId": invitee_user_id
888                        }
889                    )
890                    receive_help_reward_data = receive_help_reward_response.json()
891                    if receive_help_reward_data.get("status") == 200:
892                        droplet = receive_help_reward_data.get("data").get("droplet")
893                        fn_print(f"用户【{self.user_name}】,===领取助力奖励成功✅✅,获得{droplet}g水滴💧===")
894                        continue
895                    fn_print(f"用户【{self.user_name}】,===领取助力奖励失败❌, {receive_help_reward_data}===")
896                return
897            fn_print(f"用户【{self.user_name}】,===领取助力奖励失败❌, {receive_help_reward_list_data}===")
898        else:
899            fn_print(
900                f"用户【{self.user_name}】,===领取助力奖励发生异常❌, {receive_help_reward_list_response.status_code}===")
901
902    async def receive_hybrid_online_reward(self):
903        """
904        领取合种上线奖励
905        :return: 
906        """
907        team_reward_list_response = await self.client.get(
908            url=f"https://app.dewu.com/hacking-tree/v1/team/sign/list?teamTreeId={self.tree_id}",
909            headers=self.headers
910        )
911        if team_reward_list_response.status_code == 200:
912            team_reward_list_data = team_reward_list_response.json()
913            if team_reward_list_data.get("data") is None:
914                return
915            reward_list = team_reward_list_data.get("data", {}).get("list")
916            if not reward_list:
917                return
918            for rewaed in reward_list:
919                if rewaed.get("isComplete") and not rewaed.get("isReceive"):
920                    receive_hybrid_online_reward_response = await self.client.post(
921                        url="https://app.dewu.com/hacking-tree/v1/team/sign/receive",
922                        headers=self.headers,
923                        json={
924                            "teamTreeId": self.tree_id,
925                            "day": rewaed.get("day")
926                        }
927                    )
928                    receive_hybrid_online_reward_data = receive_hybrid_online_reward_response.json()
929                    if receive_hybrid_online_reward_data.get("data").get("isOk"):
930                        fn_print(f"用户【{self.user_name}】,===领取合种上线奖励成功✅✅, 获得{rewaed.get('num')}g水滴💧===")
931                        continue
932                    fn_print(f"用户【{self.user_name}】,===领取合种上线奖励失败❌, {receive_hybrid_online_reward_data}===")
933        return
934
935    async def receive_air_drop(self):
936        """
937        领取空中水滴
938        :return: 
939        """
940        for _ in range(2):
941            receive_air_drop_response = await self.client.post(
942                url="https://app.dewu.com/hacking-tree/v1/droplet/air_drop_receive",
943                headers=self.headers,
944                json={
945                    "clickCount": 20,
946                    "time": int(time.time())
947                }
948            )
949            if receive_air_drop_response.status_code == 200:
950                receive_air_drop_data = receive_air_drop_response.json()
951                data = receive_air_drop_data.get("data")
952                if data is not None and data.get("isOk"):
953                    fn_print(f"用户【{self.user_name}】,===领取空中水滴成功✅✅,获得{data.get('droplet')}g水滴💧===")
954                    await asyncio.sleep(1)
955                    continue
956                break
957
958    async def click_product(self):
959        products = [
960            {"spuId": 3030863, "timestamp": 1690790735382, "sign": "2889b16b3077c5719288d105a14ffa1e"},
961            {"spuId": 4673547, "timestamp": 1690790691956, "sign": "cc3cc95253d29a03fc6e79bfe2200143"},
962            {"spuId": 1502607, "timestamp": 1690791565022, "sign": "04951eac012785ccb2600703a92c037b"},
963            {"spuId": 2960612, "timestamp": 1690791593097, "sign": "fb667d45bc3950a7beb6e3fa0fc05089"},
964            {"spuId": 3143593, "timestamp": 1690791613243, "sign": "82b9fda61be79f7b8833087508d6abe2"},
965            {"spuId": 3067054, "timestamp": 1690791639606, "sign": "2808f3c7cf2ededea17d3f70a2dc565d"},
966            {"spuId": 4448037, "timestamp": 1690791663078, "sign": "335bc519ee9183c086beb009adf93738"},
967            {"spuId": 3237561, "timestamp": 1690791692553, "sign": "5c113b9203a510b7068b3cd0f6b7c25e"},
968            {"spuId": 3938180, "timestamp": 1690792014889, "sign": "3841c0272443dcbbab0bcb21c94c6262"}
969        ]
970        for product in products:
971            product_response = await self.client.post(
972                url="https://app.dewu.com/hacking-tree/v1/product/spu",
973                headers=self.headers,
974                json=product
975            )
976            if product_response.status_code == 200:
977                product_data = product_response.json()
978                if product_data.get("data") is None:
979                    fn_print(f"用户【{self.user_name}】,===今天已经完成过这个任务了❌, {product_data}===")
980                    return
981                if product_data.get("data").get("isReceived"):
982                    fn_print(f"用户【{self.user_name}】,===获得{product_data.get('data').get('dropLetReward')}g水滴💧")
983                    return
984                await asyncio.sleep(1)
985            else:
986                fn_print(f"用户【{self.user_name}】,===点击商品任务请求异常❌, {product_response.status_code}===")
987
988    async def receive_discover_droplet(self):
989        """
990        领取发现水滴
991        :return: 
992        """
993        while True:
994            receive_discover_droplet_response = await self.client.post(
995                url="https://app.dewu.com/hacking-tree/v1/product/task/seek-receive",
996                headers=self.headers,
997                json={
998                    "sign": "9888433e6d10b514e5b5be4305d123f0",
999                    "timestamp": int(time.time() * 1000)
1000                }
1001            )
1002            if receive_discover_droplet_response.status_code == 200:
1003                receive_discover_droplet_data = receive_discover_droplet_response.json()
1004                fn_print(receive_discover_droplet_data)
1005
1006    async def receive_brand_specials(self):
1007        """
1008        领取品牌特惠奖励
1009        :return: 
1010        """
1011        receive_brand_specials_response = await self.client.get(
1012            url="https://app.dewu.com/hacking-ad/v1/activity/compound/list?bizId=tree",
1013            headers=self.headers
1014        )
1015        if receive_brand_specials_response.status_code == 200:
1016            receive_brand_specials_data = receive_brand_specials_response.json()
1017            if receive_brand_specials_data.get("data") is None:
1018                fn_print(f"用户【{self.user_name}】,===当前没有可以完成的品牌特惠任务===")
1019                return
1020            if receive_brand_specials_data.get("data").get("list") is None:
1021                fn_print(f"用户【{self.user_name}】,===当前没有可以完成的品牌特惠任务===")
1022                return
1023            ad_list = receive_brand_specials_data.get("data").get("list")
1024            for ad in ad_list:
1025                if ad.get("isReceived"):
1026                    continue
1027                aid = ad.get("task").get("taskId")
1028                receive_brand_specials_response = await self.client.post(
1029                    url="https://app.dewu.com/hacking-ad/v1/activity/receive",
1030                    headers=self.headers,
1031                    json={"bizId": "tree", "aid": aid}
1032                )
1033                receive_brand_specials_data = receive_brand_specials_response.json()
1034                fn_print(
1035                    f"用户【{self.user_name}】,===领取品牌特惠奖励成功✅✅, {receive_brand_specials_data.get('data').get('award')}g水滴💧===")
1036                await asyncio.sleep(1)
1037        else:
1038            fn_print(
1039                f"用户【{self.user_name}】,===领取品牌特惠奖励请求异常❌, {receive_brand_specials_response.status_code}===")
1040
1041    async def get_tree_planting_progress(self):
1042        """
1043        获取许愿树的进度
1044        :return: 
1045        """
1046        get_tree_planting_progress_response = await self.client.get(
1047            url="https://app.dewu.com/hacking-tree/v1/tree/get_tree_info",
1048            headers=self.headers
1049        )
1050        if get_tree_planting_progress_response.status_code == 200:
1051            get_tree_planting_progress_data = get_tree_planting_progress_response.json()
1052            if get_tree_planting_progress_data.get("code") != 200:
1053                fn_print(f"用户【{self.user_name}】,===获取许愿树进度失败❌, {get_tree_planting_progress_data}===")
1054                return
1055            self.tree_id = get_tree_planting_progress_data.get("data").get("treeId")
1056            level = get_tree_planting_progress_data.get("data").get("level")
1057            current_level_need_watering_droplet = get_tree_planting_progress_data.get("data").get(
1058                "currentLevelNeedWateringDroplet")
1059            user_watering_droplet = get_tree_planting_progress_data.get('data').get('userWateringDroplet')
1060            fn_print(
1061                f"用户【{self.user_name}】,===当前许愿树等级:{level}级{user_watering_droplet}/{current_level_need_watering_droplet}===")
1062        else:
1063            fn_print(
1064                f"用户【{self.user_name}】,===获取许愿树进度请求异常❌, {get_tree_planting_progress_response.status_code}===")
1065
1066    async def waterting(self):
1067        """
1068        浇水
1069        :return: 
1070        """
1071        if self.is_team_tree:
1072            return await self.team_waterting()
1073        waterting_response = await self.client.post(
1074            url="https://app.dewu.com/hacking-tree/v1/tree/watering",
1075            headers=self.headers
1076        )
1077        if waterting_response.status_code == 200:
1078            waterting_data = waterting_response.json()
1079            if waterting_data.get("code") != 200:
1080                fn_print(f"用户【{self.user_name}】,===浇水失败❌, {waterting_data}===")
1081                return False
1082            fn_print(f"用户【{self.user_name}】,===浇水成功✅✅===")
1083            if waterting_data.get("data").get("nextWateringTimes") == 0:
1084                fn_print(f"用户【{self.user_name}】,===开始领取浇水奖励===")
1085                await asyncio.sleep(1)
1086                await self.receive_watering_reward()
1087            return True
1088        else:
1089            fn_print(f"用户【{self.user_name}】,===浇水发生异常❌, {waterting_response.status_code}===")
1090            return False
1091
1092    async def team_waterting(self):
1093        waterting_response = await self.client.post(
1094            url="https://app.dewu.com/hacking-tree/v1/team/tree/watering",
1095            headers=self.headers,
1096            json={
1097                "teamTreeId": self.tree_id
1098            }
1099        )
1100        if waterting_response.status_code == 200:
1101            team_waterting_data = waterting_response.json()
1102            if team_waterting_data.get("code") != 200:
1103                fn_print(f"用户【{self.user_name}】,===浇水失败❌, {team_waterting_data}===")
1104                return False
1105            fn_print(f"用户【{self.user_name}】,===浇水成功✅✅,成功浇水{self.waterting_g}g===")
1106            if team_waterting_data.get("data").get("nextWateringTimes") == 0:
1107                fn_print(f"用户【{self.user_name}】,===开始领取浇水奖励===")
1108                await asyncio.sleep(1)
1109                await self.receive_watering_reward()
1110            return True
1111        else:
1112            fn_print(f"用户【{self.user_name}】,===浇水发生异常❌, {waterting_response.status_code}===")
1113
1114    async def run(self):
1115        await self.get_user_info()
1116        name, level = await self.tree_info()
1117        droplet_number = await self.get_droplet_number()
1118        if not (name and level and droplet_number >= 0):
1119            fn_print("请求数据异常!")
1120            return
1121        fn_print(f"用户【{self.user_name}】,===当前水滴数:{droplet_number}===")
1122        await self.determine_whether_is_team_tree()
1123        await self.get_tree_planting_progress()
1124        # if HELP_SIGNAL:
1125        #     fn_print(f"用户【{self.user_name}】,===开始获取助力码===")
1126        #     share_code_list.append(await self.get_share_code())
1127        task_list = [
1128            self.droplet_sign_in(),
1129            self.receive_droplet_extra(),
1130            self.execute_task(),
1131            self.execute_cumulative_task(),
1132            self.judging_bucket_droplet(),
1133            self.execute_receive_watering_reward(),
1134            # self.waterting_droplet_extra(),
1135            self.receive_hybrid_online_reward(),
1136            self.receive_air_drop(),
1137            self.droplet_invest(),
1138            self.click_product(),
1139            # self.receive_brand_specials(),
1140            # self.help_user(),
1141            self.receive_help_reward(),
1142            self.receive_level_reward(),
1143            self.waterting_until_less_than()
1144        ]
1145        await asyncio.gather(*task_list)
1146        await self.get_tree_planting_progress()
1147
1148
1149async def main():
1150    task = []
1151    for index, (dw_x_auth_token, sk) in enumerate(zip(dw_x_auth_tokens, dw_sks)):
1152        dw = DeWu(dw_x_auth_token, index, sk)
1153        task.append(dw.run())
1154    await asyncio.gather(*task)
1155
1156
1157if __name__ == '__main__':
1158    asyncio.run(main())
1159    send_notification_message_collection("得物森林通知 - {}".format(datetime.now().strftime("%Y/%m/%d")))
1160

提示下载与运行前务必自行通读源码,警惕可疑外联与凭证窃取。