import nest_asyncio
nest_asyncio.apply()

import aiohttp
import asyncio
headers = {
    'User-Agent' : 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.5112.102 Safari/537.36 Edg/104.0.1293.63'
}

async with aiohttp.ClientSession() as session:
    async with session.request(
        'GET',
        'https://wldcmzy.github.io/',
        headers = headers
    ) as res:
        print(await res.text(encoding='utf-8'))

async with aiohttp.ClientSession() as session:
    async with session.get(
        'https://wldcmzy.github.io/',
        headers = headers
    ) as res:
        print(await res.text(encoding='utf-8'))

session = aiohttp.ClientSession()
res = await session.request(
    'GET',
    'https://wldcmzy.github.io/',
    headers = headers
)
print(await res.text(encoding='utf-8'))
session.close()

async with aiohttp.ClientSession(headers = headers) as session:
    async with session.get(
        'https://wldcmzy.github.io/',
        headers = headers
    ) as res:
        print(await res.text(encoding='utf-8'))

import aiohttp
import asyncio
import time
urls = [
    'https://wldcmzy.github.io/',
    'https://docs.aiohttp.org/en/stable/index.html',
    'https://github.com/Nearrin/HollowKnight.PureZote',
    'https://www.baidu.com/',
]
async def getHTML(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as res:
            print(time.time(), (await res.text())[ : 100], sep = '\n', end = '\n<<<<<<<<<<<<<\n')

loop = asyncio.get_event_loop()
tasks = [asyncio.ensure_future(getHTML(each)) for each in urls]
tasks = asyncio.gather(*tasks)
loop.run_until_complete(tasks)

import aiohttp
import asyncio
import time

URLS = [
    'https://wldcmzy.github.io/',
    'https://docs.aiohttp.org/en/stable/index.html',
    'https://www.baidu.com/',
    'https://blog.csdn.net/mixintu/article/details/102424471',
]

async def getHTML(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as res:
            return url, res.status

async def work(lst, semaphore):
    async with semaphore:
        url, sta = await getHTML(lst)
        print(url, sta)

# async def main(loop: asyncio.AbstractEventLoop) -> None:
async def main() -> None:

    semaphore = asyncio.Semaphore(2)
    tasks = [work(each, semaphore) for each in URLS]
    await asyncio.wait(tasks)
    print('ok')

if __name__ == '__main__':
    loop = asyncio.get_event_loop()
    try:
        st = time.time()
        print('wait', st)
        loop.run_until_complete(main())
        print('over, usetime:', time.time() - st , 's')
        st = time.time()
        print('wait 2nd', st)
        loop.run_until_complete(main())
        print('over, usetime:', time.time() - st , 's')
    finally:
        # loop.close()
        print('closed')

from bs4 import BeautifulSoup
import re
from Wrappers import logger, remove_invalid_element_in_windows_path, try_except_ensure
from Wrappers.Affix import Affix_OnlyZeroExample
from Wrappers.HTMLwrapper import Image_HTMLwrapper_Lv2
import os
import aiohttp
import asyncio

class SpiderX:
    DOMIN: str = 'https://www.didiaomh.com/'

    def __init__(
        self,
        catalog_url: str,
        outpath_name: str = 'out',
        capture_format: str = 'capture{arg}',
        image_format: str = 'image{arg}.jpg',
        max_capture_number_length: int = 3,
        max_page_number_length: int = 3,
        work_span: tuple[int] = (0, 0),
        concurrency: int = 5,
        myproxy = None,
        # headers: dict = {},
    ) -> None:
        '''
        catalog_url:
            目录页链接
        outpath_name:
            输出路径名
        capture_format:
            章节格式
        image_format:
            图片格式
        max_capture_number_length: 
            最大章节序号长度
        max_page_number_length:
            最大图片序号长度
        work_span: tuple[int]:
            爬取章节范围(小, 大)
            默认爬取所有
        concurrency:
            同时进行的任务数量
        proxies:
            代理服务器信息
        '''
        self.catalog_url = catalog_url if catalog_url[ : len(self.DOMIN)] == self.DOMIN else self.DOMIN + catalog_url
        self.outpath_name = outpath_name
        self.check_path(self.outpath_name)
        self.capture_format = capture_format
        self.image_format = image_format
        self.max_capture_number_length = max_capture_number_length
        self.max_page_number_length = max_page_number_length
        self.work_span = work_span
        self.myproxy = myproxy

        self.page_counter = 0
        self.affix = Affix_OnlyZeroExample()

        self.semaphore = asyncio.Semaphore(concurrency)
        self.session = aiohttp.ClientSession()


    def toreload_format_page_name(self, index: int):
        return self.image_format.format(arg = self.affix.add_prefix(str(index), self.max_page_number_length))
    def toreload_format_capture_name(self, index: int, capture_title: str):
        return self.capture_format.format(arg = self.affix.add_prefix(str(index), self.max_page_number_length) + capture_title)

    def check_path(self, path: str) -> None:
        '''检查目录存在性,若目录没有, 则创建'''
        if not os.path.exists(path):
            os.mkdir(path)
            logger.debug(f'建立目录:{path}...')

    async def get_html(self, url: str) -> str:
        '''抓取网页html信息'''
        async with self.semaphore:
            async with self.session.get(url, proxy = self.myproxy) as response:
                return await response.text()

    async def get_catalog(self) -> dict[int, tuple[str, str]]:
        '''
        生成漫画目录 (章节-url 映射)
        return: 
            { index : (url, capture_title), }
        '''
        html = await self.get_html(self.catalog_url)
        soup = BeautifulSoup(html) 
        li_tag_list: list[BeautifulSoup] = soup.find('ul', class_ = 'chapter-list clearfix').findAll('li')
        catalog = {}
        for i, each in enumerate(li_tag_list):
            catalog[i + 1] = self.DOMIN + each.a['href'], each.a.string 
        return catalog

    async def save_image(self, pathname: str, data: bytes) -> None:
        '''保存一张图片'''
        with open(pathname, 'wb') as f:
            f.write(data)

    async def download_one_image(self, url: str, pathname: str) -> None:
        '''下载一张图片'''
        async with self.session.get(url) as res:
            await self.save_image(pathname, await res.read())

    async def download_one_capture_perpage(self, soup: BeautifulSoup, foldername: str) -> None:
        '''下载一html页的图片'''
        li_tag_list: list[BeautifulSoup] = soup.find('div', class_ = 'comiclist').findAll('div', class_ = 'comicpage')
        tasks = []
        for each in li_tag_list:
            url: str = each.img['src']
            self.page_counter += 1
            filename = remove_invalid_element_in_windows_path(self.toreload_format_page_name(self.page_counter))
            tasks.append(asyncio.ensure_future(self.download_one_image(url, f'{self.outpath_name}/{foldername}/{filename}')))
        await asyncio.wait(tasks)

            
    async def download_one_capture(self, url: str, foldername: str) -> None:
        '''下载一章图片'''
        self.check_path(f'{self.outpath_name}/{foldername}')
        self.page_counter = 0
        html = await self.get_html(url)
        soup = BeautifulSoup(html)
        total_pages = int(re.search('第[0-9]+/([0-9]+)页', soup.find('select', class_ = 'selectpage').option.string).group(1))
        logger.log('html page 1')
        await self.download_one_capture_perpage(soup, foldername)
        for i in range(2, total_pages + 1):
            logger.log(f'html page {i}')
            html = await self.get_html(url.replace('.html', f'?page={i}'))
            soup = BeautifulSoup(html)
            await self.download_one_capture_perpage(soup, foldername)

    @try_except_ensure
    async def download_all_caputres(self) -> None:
        '''下载漫画所有图片'''
        catalog = await self.get_catalog()
        work_span_low, work_span_high = self.work_span
        flag = work_span_high > work_span_low
        logger.debug(f'work span flag:{flag}, low:{work_span_low}, high:{work_span_high}')
        for key, value in catalog.items():
            if flag:
                if key > work_span_high or key < work_span_low:
                    continue
            logger.log(f'章节进度:{key}/{len(catalog)}')
            url, capture_title = value
            capture_name = remove_invalid_element_in_windows_path(self.toreload_format_capture_name(key, capture_title))
            await self.download_one_capture(url, capture_name)


if __name__ == '__main__':
    loop = asyncio.get_event_loop()

    x = SpiderX(
        'https://www.didiaomh.com/manhua/6500.html',
        outpath_name = '偷星九月天IMAGES',
    )
    
    try:
        loop.run_until_complete(x.download_all_caputres())
    except Exception as e:
        logger.error(f'{type(e)}|{str(e)}')
    finally:
        loop.close()

#===========================================================================

    class TX9MOONSKY(Image_HTMLwrapper_Lv2):
        def __init__(
            self, 
            root: str,
            html_path: str,
            html_vital_element: str,
            html_collection_name,
            prefix_LvRoot: str, 
            prefix_Lv2: str,
        ) -> None:
            super().__init__(
                root, 
                html_path, 
                html_vital_element, 
                html_collection_name,
                prefix_LvRoot,
                prefix_Lv2
            )
        
        def toreload_parse_diff_element_title(self, folder_name: str) -> str:
            return super().toreload_parse_diff_element_title(folder_name)
        
        def toreload_parse_diff_element_P(self, folder_name: str) -> str:
            return super().toreload_parse_diff_element_P(folder_name)[3 : ]


    y = TX9MOONSKY(
        root = '偷星九月天IMAGES',
        html_path = '偷星九月天HTMLS',
        html_vital_element= '偷星九月天 {arg}',
        html_collection_name= ' 偷星九月天 全集 ',
        prefix_LvRoot='capture',
        prefix_Lv2='image'
    )
    y.create_htmls()

import requests
import re
import bs4
import time
import os
import typing

class MyEasylogger:
    def __init__(self, path: str = './', filename = 'DownloadLOG.log') -> None:
        self.path = path
        self.filename = filename
        self.makelog('MyEasylogger类被实例化', 'MyEasylogger', False)

    def makelog(self, data: str, tag: str = 'default', ifprint: bool = True) -> None:
        if ifprint:
            print(data)
        ifexist = os.path.exists(self.filename)
        with open(self.path + self.filename, 'a+') as f:
            if not ifexist:
                f.write(f'==> {str(time.localtime()[ : 6])} | [MyEasylogger] 日志建立\n')
            f.write(f'==> {str(time.localtime()[ : 6])} | [{tag}] {data}\n')

    def log(self, data: str, ifprint = True):
        self.makelog(data, 'log', ifprint)

    def debug(self, data: str, ifprint = True):
        self.makelog(data, 'debug', ifprint)

    def error(self, data: str, ifprint = True):
        self.makelog(data, 'error', ifprint)
logger = MyEasylogger()

def try_except_ensure(func):
    def _(*args):
        try:
            return func(*args)
        except Exception as e:
            def __(e : Exception, *args) -> None: 
                logger.error(str(type(e)) + '|' + str(e))
            return __(e, *args)
    return _

class Downloader:
    DOMIN = 'http://rimanb.com/'

    HTML = '''
<!DOCTYPE html>
<html>
<head>
	<title>{capture}</title>
	<meta charset="utf-8">
    <style>
        body{{
            background-color: black;
        }}
		div#pages{{
            text-align: center;
		}}
        p#p{{
            font-size: 35px;
            text-align: center;
            color: #66ffff;
        }}
        span#capture_number{{
            color: #ff66ff;
        }}
	</style>
    
</head>
<body>
{args}
</body>
</html>
'''
    IMAGE = '    <div id="pages"><img onload="if(this.width >= document.documentElement.clientWidth){{this.width = document.documentElement.clientWidth}}" align="middle" src="{page}"></img></div>\n'
    P = '   <p id="p"><strong>{caricature_name} 第 <span id="capture_number">{p}</span> 话</strong></p>\n'
    SEP = '<br><br>\n    <hr style="FILTER:alpha(opacity=100,finishopacity=0,style=3)" width="95%"color=#00FF7F SIZE=5>'
    def __init__(
        self,
        catalog_url: str = 'http://rimanb.com/book/2407',
        start_end: tuple[int, int] = (39, 232),
        image_format: str = '.jpg',
        outpath_root: str = './out/',
        htmlpath: str = './html/',
        caricature_name: str = 'Mr.STONE石纪元',
        page_number_length:int = 2,
        capture_number_length: int = 3,
        headers: dict = {
            'User-Agent': r'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.5112.81 Safari/537.36 Edg/104.0.1293.47', 
        }, 
    ) -> None:
        '''
        catalog_url:
            漫画的章节列表页面url
        start_end:
            爬取漫画的起始和终止章节
        image_format:
            图片保存格式
        outpath_root:
            输出根路径, 以/结尾
        htmlpath:
            以便于观看的html文件整合图片,html文件的输出路径
        caricature_name:
            漫画名称, 用于html要素命名
        page_number_length:
            命名图片序号所需的字符串长度
        capture_number_length:
            命名章节序号所需的字符串长度
        headers:
            请求头信息
        '''
        self.start, self.end = start_end
        self.catalog_url = catalog_url
        self.image_format = image_format
        self.outpath_root = outpath_root
        self.htmlpath = htmlpath
        self.caricature_name = caricature_name
        self.page_number_length = page_number_length
        self.capture_number_length = capture_number_length
        self.headers = headers
        if not os.path.exists(self.outpath_root):
            os.mkdir(self.outpath_root)
            logger.debug(f'输出目录{self.outpath_root}不存在, 已经成功建立...')

    def prefix_zero(self, ss: typing.Union[str, int], leng: int) -> str:
        '''
        为字符串ss填充前导0使其达到长度leng
        ss:
            初始字符串
        leng:
            目标长度
        '''
        ss = str(ss)
        assert len(ss) <= leng
        if len(ss) < leng:
            ss = '0' * (leng - len(ss))  + ss
        return ss

    def format_page_number(self, page: str) -> None:
        '''
        把页码前面补0扩展到正确长度
        page: 
            页码字符串
        '''
        return self.prefix_zero(page, self.page_number_length)

    def format_capture_number(self, cap: str) -> None:
        '''
        把章节前面补0扩展到正确长度
        cap: 
            章节码字符串
        '''
        return self.prefix_zero(cap, self.capture_number_length)

    def get_url_dict(self) -> dict[int, str]:
        '''
        获得漫画每一章的url
        return: dic
            漫画的所有章节的章节号-url映射表
            {章节号 : url}
        '''
        res = requests.get(self.catalog_url, headers = self.headers)
        soup = bs4.BeautifulSoup(res.text)
        lst = soup.findAll('span', class_ = 'works-chapter-item')
        dic = {}
        for each in lst:
            id = re.search('第([0-9]+)话', str(each.a['title'])).group(1)
            href = each.a['href']
            dic[int(id)] = Downloader.DOMIN +  href
        return dic

    def parse_capture(self, url: str) -> list[tuple[int, str]]:
        '''
        获取漫画特定章节的所有图片的链接
        url: 
            漫画特定章节的url
        return: lst
            url对应漫画章节的所有图片链接
            [(图片序号, url), ]
        '''
        res = requests.get(url, headers = self.headers)
        soup = bs4.BeautifulSoup(res.text)
        imgs = soup.find('ul', id = 'comicContain', class_ = 'comic-contain').findAll('li')
        lst = []
        for i, each in enumerate(imgs):
            lst.append((i + 1, Downloader.DOMIN + each.img['src']))
        return lst

    def download_one_picture(self, url: str, filepath: str, filename: str) -> None:
        '''
        下载一张图片
        url: 
            图片地址
        filepath: 
            文件路径, 以"/"结尾
        filename: 
            文件名
        '''
        res = requests.get(url, headers = self.headers)
        with open(f'{filepath}{filename}.{self.image_format}', 'wb') as f:
            f.write(res.content)
        logger.log(f'下载图片并保存为{filepath}{filename}.{self.image_format}完成...')

    @try_except_ensure
    def run(self) -> None:
        '''
        下载图片
        下载的漫画链接为: self.catalog_url
        下载的起始章节为: self.start
        下载的结束章节为: self.end
        下载的图片保存为: self.outpath_root/capture章节号/page图片号.self.imageformat
        '''
        logger.log(f'开始下载,漫画目录s链接为:{self.catalog_url}')
        logger.log('正在获取章节目录...')
        self.url_dict = self.get_url_dict()
        logger.log(f'章节目录获取完成,共{len(self.url_dict)}个项目...')
        for capture in range(self.start, self.end + 1):
            logger.log(f'!!!章节进度: {capture}({self.start}-{self.end}) ({capture - self.start + 1}/{self.end - self.start + 1})')
            outpath = f'{self.outpath_root}capture{self.format_capture_number(capture)}/'
            if not os.path.exists(outpath):
                logger.debug(f'创建目录{outpath}')
                os.mkdir(outpath)
            if capture not in self.url_dict:
                logger.error(f'在章节目录中没有第{capture}章的记录(KeyError:{capture})')
                continue
            image_list = self.parse_capture(self.url_dict[capture])
            for pid, purl in image_list:
                logger.log(f'!图片进度: ({pid}/{len(image_list)})')
                self.download_one_picture(purl, outpath,'page' + self.format_page_number(pid))
        logger.log('下载结束...')

    def combie_one_caputre_images_to_html(self, folder_name: int) -> str:
        '''
        把一整章的图片链接都整合为html语言图片块
        folder_name:
            特定章节对应的文件夹名
        return: html
            拥有folder_name文件夹中所有以page链接的html文件格式字符串
        '''
        pages = [each for each in os.listdir(self.outpath_root + folder_name) if each[ : 4] == 'page']
        pages = sorted(pages)
        html = ''
        image_src = '../' + self.outpath_root + folder_name + '/'
        for each in pages:
            html += Downloader.IMAGE.format(page = image_src + each)
        return html
    
    def create_one_html(self, name: str, html: str, collection: bool = False) -> None:
        '''
        生成一章漫画的html文件
        name:
            要生成的html文件名称
        html:
            本章漫画图片的html格式字符串
        collection:
            本次是否生成总集
        '''
        index = f'第{int(name[7 : ])}话' if not collection else '总集篇'
        with open(self.htmlpath + self.caricature_name + '_' + name + '.html', 'w', encoding='utf-8') as f:
            f.write(Downloader.HTML.format(capture = f'{self.caricature_name} {index}', args = html))
    
    def create_htmls(self, collection: bool = True) -> None:
        '''
        为漫画所有章节生成html文件
        collection:
            是否生成总集篇文件
        '''
        if not os.path.exists(self.htmlpath):
            os.mkdir(self.htmlpath)
            logger.debug(f'{self.htmlpath}不存在, 建立成功')
        logger.log(f'开始为漫画创建html文件, {"" if collection else "不"}包括创建总集篇')
        capture_folders = [each for each in os.listdir(self.outpath_root) if each[ : 7] == 'capture']
        totalhtml = ''
        for each in capture_folders:
            html = Downloader.SEP
            html += Downloader.P.format(p = int(each[7 : ]), caricature_name = self.caricature_name)
            html += self.combie_one_caputre_images_to_html(each)
            self.create_one_html(each, html)
            logger.log(each + 'html创建完成...')
            if collection:
                totalhtml += html
        if collection:
            self.create_one_html('ALL CAPTURES', totalhtml, True)
            logger.log('总集篇html创建完成...')

        
if __name__ == '__main__':
    d = Downloader()
    d.run()
    d.create_htmls()

import os
import hashlib

path = 'out/'
folders = os.listdir(path)
lst404 = []
for folder in folders:
    pages = os.listdir(path + folder + '/')
    dic = {}
    for page in pages:
        with open(path + folder + '/' + page, 'rb') as f:
            hasher = hashlib.md5(f.read())
            hash = hasher.hexdigest()
        if hash not in dic: 
            dic[hash] = 1
        else:
            lst404.append(folder)
            print(folder)
            break
with open('404captures.txt', 'w') as f:
    for each in lst404:
        f.write(each + '\n')

from asyncio.log import logger
import requests
from bs4 import BeautifulSoup
import re
from time import localtime
from os import mkdir
from os.path import exists
import asyncio

class Mylogger:
    def __init__(self) -> None:
        pass

    # def inactive(self) -> None:
    #     self.fp.close()

    def log(self, data: str, ifprint = True) -> None:
        if ifprint:
            print(data)

        #换异步后可能报错 log可禁用
        #return None
        with open('DownloadLOG.log', 'a+') as f:
            f.write(f'==> {str(localtime()[ : 6])} | {data}\n')

class Downloader:

    DrSTONE_ADDR = 25638 - 1

    # 页码长度
    PAGE_NUMBER_LENGTH = 2

    # 章节长度
    CAPTURE_NUMBER_LENGTH = 3

    # 起始，截至章节
    CAPTURE_START, CAPTURE_END = 1, 233

    # 基础漫画地址
    BASE_URL = r'https://omyschool.com/article_detail/152/{addr}/Dr.STONE%20%E7%9F%B3%E7%BA%AA%E5%85%83/{cap}%E8%A9%B1/'

    # 请求头信息
    MY_HEADERS = {
        'User-Agent': r'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.5112.81 Safari/537.36 Edg/104.0.1293.47', 

    }

    # 保存路径
    PATH = './out/'

    def __init__(self) -> None:
        self.logger = Mylogger()
        if not exists(Downloader.PATH):
            mkdir(Downloader.PATH)

    def prefix_zero(self, ss: str, leng: int) -> str:
        '''为字符串ss填充前导0使其达到长度leng'''
        ss = str(ss)
        if len(ss) < leng:
            ss = '0' * (leng - len(ss))  + ss
        return ss

    def format_page_number(self, page: str) -> None:
        '''
        把页码前面补0扩展到正确长度
        page: 页码字符串
        '''
        return self.prefix_zero(page, Downloader.PAGE_NUMBER_LENGTH)

    def format_capture_number(self, cap: str) -> None:
        '''
        把章节前面补0扩展到正确长度
        cap: 章节码字符串
        '''
        return self.prefix_zero(cap, Downloader.CAPTURE_NUMBER_LENGTH)

    def form_capture_url(self, capture: int) -> str:
        '''
        返回第capture章的网页地址
        capture: 章序号
        '''
        str_capture = str(capture)
        str_addr = str(Downloader.DrSTONE_ADDR + capture)
        if capture < 10: str_capture = '0' + str_capture
        return Downloader.BASE_URL.format(cap = str_capture, addr = str_addr)

    async def download_one_picture(self, url: str, filepath: str, filename: str) -> None:
        '''
        下载一张图片
        url: 图片地址
        filepath: 文件路径, 以"/"结尾
        filenamer: 文件名
        page: 页码号 用于显示进度
        '''
        try:
            fileformat = url.split('.')[-1]
            res = requests.get(url, headers=Downloader.MY_HEADERS)
            with open(f'{filepath}{filename}.{fileformat}', 'wb') as f:
                f.write(res.content)
            print(f'{filepath}{filename}.{fileformat}完成...')
        except Exception as e:
            self.logger.log(f'{type(e)} | {str(e)} | 下载图片{filepath}{filename}时出错。')

    def parse_one_capture(self, capture_number: int) -> list[tuple[str, str]]:
        '''
        解析第capture_number章的内容, 返回这一章所有图片的链接和序号
        capture_number: 章序号
        '''
        try:
            url = self.form_capture_url(capture_number)
            print(url)
            res = requests.get(url, headers=Downloader.MY_HEADERS)
            soup = BeautifulSoup(res.text.replace('amp-img', 'amp_img'))
            data_list = soup.find_all('div', {'data-id': True})
            image_list = []
            for each in data_list:
                picture_url = each.amp_img['src']
                picture_id = re.search('第([0-9]+)页', each.amp_img['alt']).group(1)
                image_list.append((picture_url, picture_id))
            return image_list
        except Exception as e:
            self.logger.log(f'{type(e)} | {str(e)} | 解析第{capture_number}章链接时出错，可能部分或全部图片未正确下载。')
            return []

    def run(self):
        '''主方法'''
        #try:
        print('开始下载...')
        for capture in range(Downloader.CAPTURE_START, Downloader.CAPTURE_END + 1):
            print(f'章进度:{capture - Downloader.CAPTURE_START + 1} / {Downloader.CAPTURE_END + 1 - Downloader.CAPTURE_START}')
            path = f'{Downloader.PATH}capture{self.format_capture_number(capture)}/'
            if not exists(path):
                mkdir(path)
            image_list = self.parse_one_capture(capture)
            if not image_list: continue
            tasks = []
            for picture_url, picture_id in image_list:
                tasks.append(asyncio.ensure_future(
                    self.download_one_picture(
                    picture_url, 
                    path,
                    'page' + self.format_page_number(picture_id)
                    )
                ))
            loop = asyncio.get_event_loop()
            loop.run_until_complete(asyncio.wait(tasks))
        print('下载结束...')
        # except Exception as e:
        #     self.logger.log(f'{type(e)} | {str(e)} | run方法遇到未知错误')

if __name__ == '__main__':
    d = Downloader()
    d.run()

from asyncio.log import logger
import requests
from bs4 import BeautifulSoup
import re
from time import localtime
from os import mkdir
from os.path import exists
import asyncio

class Mylogger:
    def __init__(self) -> None:
        pass

    # def inactive(self) -> None:
    #     self.fp.close()

    def log(self, data: str, ifprint = True) -> None:
        if ifprint:
            print(data)

        #换异步后可能报错 log可禁用
        #return None
        with open('DownloadLOG.log', 'a+') as f:
            f.write(f'==> {str(localtime()[ : 6])} | {data}\n')

class Downloader:

    #DrSTONE_ADDR = 25638 - 1
    DrSTONE_ADDR = 239049 - 1

    # 页码长度
    PAGE_NUMBER_LENGTH = 2

    # 章节长度
    CAPTURE_NUMBER_LENGTH = 3

    # 起始，截至章节
    CAPTURE_START, CAPTURE_END = 136, 233

    # 基础漫画地址
    BASE_URL = r'https://omyschool.com/article_detail/152/{addr}/Dr.STONE%20%E7%9F%B3%E7%BA%AA%E5%85%83/{cap}%E8%A9%B1/'

    # 请求头信息
    MY_HEADERS = {
        'User-Agent': r'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/104.0.5112.81 Safari/537.36 Edg/104.0.1293.47', 

    }

    # 保存路径
    PATH = './out/'

    def __init__(self) -> None:
        self.logger = Mylogger()
        if not exists(Downloader.PATH):
            mkdir(Downloader.PATH)

    def prefix_zero(self, ss: str, leng: int) -> str:
        '''为字符串ss填充前导0使其达到长度leng'''
        ss = str(ss)
        if len(ss) < leng:
            ss = '0' * (leng - len(ss))  + ss
        return ss

    def format_page_number(self, page: str) -> None:
        '''
        把页码前面补0扩展到正确长度
        page: 页码字符串
        '''
        return self.prefix_zero(page, Downloader.PAGE_NUMBER_LENGTH)

    def format_capture_number(self, cap: str) -> None:
        '''
        把章节前面补0扩展到正确长度
        cap: 章节码字符串
        '''
        return self.prefix_zero(cap, Downloader.CAPTURE_NUMBER_LENGTH)

    def form_capture_url(self, capture: int) -> str:
        '''
        返回第capture章的网页地址
        capture: 章序号
        '''
        str_capture = str(capture)
        str_addr = str(Downloader.DrSTONE_ADDR + capture)
        if capture < 10: str_capture = '0' + str_capture
        return Downloader.BASE_URL.format(cap = str_capture, addr = str_addr)

    async def download_one_picture(self, url: str, filepath: str, filename: str) -> None:
        '''
        下载一张图片
        url: 图片地址
        filepath: 文件路径, 以"/"结尾
        filenamer: 文件名
        page: 页码号 用于显示进度
        '''
        try:
            #print(url)
            fileformat = url.split('.')[-1]
            res = requests.get(url, headers=Downloader.MY_HEADERS)
            with open(f'{filepath}{filename}.{fileformat}', 'wb') as f:
                f.write(res.content)
            print(f'{filepath}{filename}.{fileformat}完成...')
        except Exception as e:
            self.logger.log(f'{type(e)} | {str(e)} | 下载图片{filepath}{filename}时出错。')

    def parse_one_capture(self, capture_number: int) -> list[tuple[str, str]]:
        '''
        解析第capture_number章的内容, 返回这一章所有图片的链接和序号
        capture_number: 章序号
        '''
        try:
            #url = self.form_capture_url(capture_number)
            url = self.NEW__form_capture_url(capture_number)
            print(url)
            res = requests.get(url, headers=Downloader.MY_HEADERS)
            soup = BeautifulSoup(res.text.replace('amp-img', 'amp_img'))
            data_list = soup.find_all('div', {'data-id': True})
            image_list = []
            for each in data_list:
                picture_url = each.amp_img['src']
                picture_id = re.search('第([0-9]+)页', each.amp_img['alt']).group(1)
                image_list.append((picture_url, picture_id))
            return image_list
        except Exception as e:
            self.logger.log(f'{type(e)} | {str(e)} | 解析第{capture_number}章链接时出错，可能部分或全部图片未正确下载。')
            return []

    def run(self):
        '''主方法'''

        self.link_dict = self.NEW_get_random_capture_url()


        #try:
        print('开始下载...')
        for capture in range(Downloader.CAPTURE_START, Downloader.CAPTURE_END + 1):
            print(f'章进度:{capture - Downloader.CAPTURE_START + 1} / {Downloader.CAPTURE_END + 1 - Downloader.CAPTURE_START}')
            path = f'{Downloader.PATH}capture{self.format_capture_number(capture)}/'
            if not exists(path):
                mkdir(path)
            image_list = self.parse_one_capture(capture)
            if not image_list: continue
            tasks = []
            for picture_url, picture_id in image_list:
                tasks.append(asyncio.ensure_future(
                    self.download_one_picture(
                    picture_url, 
                    path,
                    'page' + self.format_page_number(picture_id)
                    )
                ))
            loop = asyncio.get_event_loop()
            loop.run_until_complete(asyncio.wait(tasks))
        print('下载结束...')
        # except Exception as e:
        #     self.logger.log(f'{type(e)} | {str(e)} | run方法遇到未知错误')



    #def NEW__get_random_capture_url() -> list[tuple[str, str]]:
    def NEW_get_random_capture_url(self) -> dict[int, str]:
        '''获取Mr.STONE所有章节的链接'''
        print('获取章节目录开始...')
        DOMIN = 'https://omyschool.com'
        DrSTONE_url = r'https://omyschool.com/article_list/152/Dr.STONE%20%E7%9F%B3%E7%BA%AA%E5%85%83/'
        res = requests.get(DrSTONE_url, headers=Downloader.MY_HEADERS)
        soup = BeautifulSoup(res.text)
        lst = soup.findAll('div', {"class": "chapter"})
        #ret = []
        ret_d = {}
        for each in lst:
            href = each.a["href"]
            if 'Dr.STONE' in href:
                id = re.search('([0-9]+)[话|話]', str(each)).group(1)
        #         ret.append((DOMIN + href, id))
        # return sorted(ret, key = lambda x: int(x[1]))
                ret_d[int(id)] = DOMIN + href
        print('获取章节目录完成...')
        return ret_d

    def NEW__form_capture_url(self, capture: int) -> str:
        '''
        返回第capture章的网页地址
        capture: 章序号
        '''
        return self.link_dict[capture]




if __name__ == '__main__':
    d = Downloader()
    d.run()

import os

PICTURE_PATH = 'out/'
HTML_PATH = 'html/'

def make_one_capture_to_html(folder_name: str) -> None:
    pages = [each for each in os.listdir(PICTURE_PATH + folder_name) if each[ : 4] == 'page']
    pages = sorted(pages)
    html = '''
<!DOCTYPE html>
<html>
<head>
	<title>temp</title>
	<meta charset="utf-8">
    <style>
		div#MrSTONEpages{{
            text-align: center;
		}}
	</style>
    
</head>
<body>
{images}
</body>
</html>
'''
    img = '    <div id="MrSTONEpages"><img onload="if(this.width >= document.documentElement.clientWidth){{this.width = document.documentElement.clientWidth}}" align="middle" src="{page}"></img></div>\n'
    imgs = ''
    RELATIVE_PATH = '../' + PICTURE_PATH + folder_name + '/'
    for each in pages:
        imgs += img.format(page = RELATIVE_PATH + each)
    with open(HTML_PATH + folder_name + '.html', 'w', encoding='utf-8') as f:
        f.write(html.format(images = imgs))



if __name__ == '__main__':
    capture_folders = [each for each in os.listdir(PICTURE_PATH) if each[ : 7] == 'capture']
    for each in capture_folders:
        make_one_capture_to_html(each)
    

# 文件1
from flask_socketio import SocketIO
clearmind_socketio = SocketIO()

# 文件2
from flask import Blueprint
clearmind_blueprint = Blueprint('main', __name__)

# 启动脚本
from flask import Flask
from BackEnd.objects import clearmind_socketio
from BackEnd.routes import clearmind_blueprint
from flask_cors import CORS

def create_app(debug = True):
    app = Flask(__name__)
    app.debug = debug
    app.config['SECRET_KEY'] = 'clearmind'
    app.register_blueprint(clearmind_blueprint)
    clearmind_socketio.init_app(app)
    CORS(app, supports_credentials=True)
    from BackEnd import events
    return app


if __name__ == '__main__':
    app = create_app()
    clearmind_socketio.run(app, host='0.0.0.0', port=26666)

import threading
from flask import session, request
from flask_socketio import emit, join_room, leave_room, disconnect

# 命名空间wslogin 连接时响应
@clearmind_socketio.on('connect', namespace='/wslogin')
def login_connect():
    print_and_log('收到登录请求...')
    try:
        username = request.args['username']
        password = request.args['password']
        '''......'''
        if 4 < 5:
            # 发送reply消息
        	emit('reply', reply)
        else:
            # 发送reply消息
        	emit('reply', 'deny')
    except Exception as e:
        print_and_log(str(type(e)),str(e))
        disconnect()
        return False
   
# 命名空间wslogin 连接断开时响应
@clearmind_socketio.on('disconnect', namespace='/wslogin')
def login_disconnect():
    '''登录连接断开时执行'''
    try : 
        username = request.args['username']
        password = request.args['password']
    except:
        pass
    print_and_log(f'登录连接断开...   {username}')
    
    
    
# 命名空间wsmine 收到click信息时响应
@clearmind_socketio.on('click', namespace='/wsmine')
def mine_click(info):
    '''收到点击地图时间, 把数据中的参数抛给后端处理'''

    try :
        cookie = request.args['cookie']
        data = json.loads(info)
        x, y = data['x'], data['y']
        username, tm = cookie_user_dict[cookie]
    except Exception as e:
        print_and_log('>>> error ' +  str(type(e)) + ' ' + str(e))
        disconnect()
        return False

    '''代码'''
    
    # 广播broadcast消息
    emit('broadcast', json.dumps({'x' : x, 'y' : y, 'color' : color, 'timmer' : timmer, 'username' : username}), broadcast = True)

    '''代码'''
    
    # 广播game end消息
    emit('game end', json.dumps(CM_server.rank()), broadcast = True)
    
    '''代码'''
    
    # 广播args 消息
    emit('args', json.dumps(CM_server.args()), broadcast = True)

import socket
import threading
from typing import Tuple

class SR:
    def __init__(self, ip = '0.0.0.0', port = 27013, sz = 2048) -> None:
        self.__socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.__socket.bind((ip, port))
        self.__sz = sz
        self.__lock = threading.Lock()
        self.__datapool = []
        

    def __t_receive(self) -> None:
        '''接收消息, 应该放到单独的线程中'''
        while True:
            try:
                data, address = self.__socket.recvfrom(self.__sz)
                self.__lock.acquire()
                data = data.decode('UTF-8')
                self.__datapool.append((data, address))
                self.__lock.release()
            except:
                break

    def receive(self) -> None:
        '''开启消息接收的方法'''
        t = threading.Thread(target = self.__t_receive, name = 'receiver')
        t.start()

    def send(self, data, address) -> None:
        '''发送消息'''
        self.__socket.sendto(data.encode('UTF-8'), address)

    def getData(self) -> Tuple[str, Tuple[str, int]]:
        '''
        从消息队列中提取一条最早的数据
        return : (msg, (ip, port))
        '''
        #self.__lock.acquire()
        if len(self.__datapool) == 0: return None
        data = self.__datapool.pop(0)
        #self.__lock.release()
        return data
    
    def inactive(self):
        self.__socket.close()

# from MemoSqliteFunctions import *
import socket
import threading

HOST = '0.0.0.0'
PORT = 22222
BUFF_SIZE = 4096

def service_run():
    # 建立Socket连接, AF_INEF说明使用IPv4地址, SOCK_STREAM指明TCP协议
    serverSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    serverSocket.bind((HOST, PORT))
    serverSocket.listen(3)# 监听 

    print(f'Run at {HOST}:{PORT}')

    while True:
        # 接收TCP连接, 并返回新的Socket对象
        sk, addr = serverSocket.accept()
        print(f"客户端: {addr} 链接")

        task = threading.Thread(target = TCP_task, args=(sk, ), name = 'tcp_task')
        task.start()

    else:
        conn.close()


def TCP_task(sk : socket.socket) -> None:
	'''线程任务'''
	
    # ......
    
    while True:
        try:
            # 接收客户端发送的数据
            data = sk.recv(BUFF_SIZE)
            data = data.decode('utf-8')
            # ......
		except:
            # ......
            pass


if __name__ == '__main__':
    service_run()