kmoe-manga-downloader 1.0.0__py3-none-any.whl

kmdr/module/authenticator/utils.py

@@ -0,0 +1,25 @@
+from requests import Session
+
+def check_status(session: Session, show_quota: bool = False) -> bool:
+    response = session.get(url = 'https://kox.moe/my.php')
+
+    try:
+        response.raise_for_status()
+    except Exception as e:
+        print(f"Error: {type(e).__name__}: {e}")
+        return False
+
+    if not show_quota:
+        return True
+    
+    from bs4 import BeautifulSoup
+
+    soup = BeautifulSoup(response.text, 'html.parser')
+    
+    nickname = soup.find('div', id='div_nickname_display').text.strip().split(' ')[0]
+    print(f"=========================\n\nLogged in as {nickname}\n\n=========================\n")
+    
+    quota = soup.find('div', id='div_user_vip').text.strip()
+    print(f"=========================\n\n{quota}\n\n=========================\n")
+    return True
+    

kmdr/module/configurer/ConfigClearer.py

@@ -0,0 +1,11 @@
+from kmdr.core import Configurer, CONFIGURER
+
+@CONFIGURER.register()
+class ConfigClearer(Configurer):
+    def __init__(self, clear: str, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._clear = clear
+
+    def operate(self) -> None:
+        self._configurer.clear(self._clear)
+        print(f"Cleared configuration: {self._clear}")

kmdr/module/configurer/ConfigUnsetter.py

@@ -0,0 +1,15 @@
+from kmdr.core import Configurer, CONFIGURER
+
+@CONFIGURER.register()
+class ConfigUnsetter(Configurer):
+    def __init__(self, unset: str, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._unset = unset
+
+    def operate(self) -> None:
+        if not self._unset:
+            print("No option specified to unset.")
+            return
+        
+        self._configurer.unset_option(self._unset)
+        print(f"Unset configuration: {self._unset}")

kmdr/module/configurer/OptionLister.py

@@ -0,0 +1,19 @@
+from kmdr.core import CONFIGURER, Configurer
+
+@CONFIGURER.register(
+    hasvalues={
+        'list_option': True
+    }
+)
+class OptionLister(Configurer):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def operate(self) -> None:
+        if self._configurer.option is None:
+            print("No configurations found.")
+            return
+
+        print("Current configurations:")
+        for key, value in self._configurer.option.items():
+            print(f"\t{key} = {value}")

kmdr/module/configurer/OptionSetter.py

@@ -0,0 +1,32 @@
+from kmdr.core import Configurer, CONFIGURER
+
+from .option_validate import validate
+
+@CONFIGURER.register()
+class OptionSetter(Configurer):
+    def __init__(self, set: list[str], *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._set = set
+
+    def operate(self) -> None:
+        for option in self._set:
+            if '=' not in option:
+                print(f"Invalid option format: `{option}`. Expected format is key=value.")
+                continue
+
+            key, value = option.split('=', 1)
+            key = key.strip()
+            value = value.strip()
+
+            validated_value = validate(key, value)
+            if validated_value is None:
+                continue
+
+            self._configurer.set_option(key, validated_value)
+            print(f"Set configuration: {key} = {validated_value}")
+
+
+
+
+
+

kmdr/module/configurer/option_validate.py

@@ -0,0 +1,76 @@
+from typing import Optional
+import os
+
+__OPTIONS_VALIDATOR = {}
+
+def validate(key: str, value: str) -> Optional[object]:
+    if key in __OPTIONS_VALIDATOR:
+        return __OPTIONS_VALIDATOR[key](value)
+    else:
+        print(f"Unsupported option: {key}. Supported options are: {', '.join(__OPTIONS_VALIDATOR.keys())}")
+        return None
+
+def _register_validator(func):
+    global __OPTIONS_VALIDATOR
+
+    func_name = func.__name__
+
+    assert func_name.startswith('validate_'), \
+        f"Validator function name must start with 'validate_', got '{func_name}'"
+
+    __OPTIONS_VALIDATOR[func.__name__[9:]] = func
+    return func
+
+@_register_validator
+def validate_num_workers(value: str) -> Optional[int]:
+    try:
+        num_workers = int(value)
+        if num_workers <= 0:
+            raise ValueError("Number of workers must be a positive integer.")
+        return num_workers
+    except ValueError as e:
+        print(f"Invalid value for num_workers: {value}. {str(e)}")
+        return None
+
+@_register_validator
+def validate_dest(value: str) -> Optional[str]:
+    if not value:
+        print("Destination cannot be empty.")
+        return None
+    if not os.path.exists(value) or not os.path.isdir(value):
+        print(f"Destination directory does not exist or is not a directory: {value}")
+        return None
+
+    if not os.access(value, os.W_OK):
+        print(f"Destination directory is not writable: {value}")
+        return None
+
+    if not os.path.isabs(value):
+        print(f"Destination better be an absolute path: {value}")
+
+    return value
+
+@_register_validator
+def validate_retry(value: str) -> Optional[int]:
+    try:
+        retry = int(value)
+        if retry < 0:
+            raise ValueError("Retry count must be a non-negative integer.")
+        return retry
+    except ValueError as e:
+        print(f"Invalid value for retry: {value}. {str(e)}")
+        return None
+
+@_register_validator
+def validate_callback(value: str) -> Optional[str]:
+    if not value:
+        print("Callback cannot be empty.")
+        return None
+    return value
+
+@_register_validator
+def validate_proxy(value: str) -> Optional[str]:
+    if not value:
+        print("Proxy cannot be empty.")
+        return None
+    return value

kmdr/module/downloader/DirectDownloader.py

@@ -0,0 +1,28 @@
+from kmdr.core import Downloader, BookInfo, VolInfo, DOWNLOADER
+
+from .utils import download_file, safe_filename
+
+@DOWNLOADER.register(
+    hasvalues={
+        'method': 1
+    }
+)
+class DirectDownloader(Downloader):
+    def __init__(self, dest='.', callback=None, retry=3, num_workers=1, proxy=None, *args, **kwargs):
+        super().__init__(dest, callback, retry, num_workers, proxy, *args, **kwargs)
+
+    def _download(self, book: BookInfo, volume: VolInfo, retry: int):
+        sub_dir = safe_filename(book.name)
+        download_path = f'{self._dest}/{sub_dir}'
+
+        download_file(
+            self._session,
+            self.construct_download_url(book, volume),
+            download_path,
+            f'[Kmoe][{book.name}][{volume.name}].epub',
+            retry,
+            callback=lambda: self._callback(book, volume) if self._callback else None
+        )
+
+    def construct_download_url(self, book: BookInfo, volume: VolInfo) -> str:
+        return f'https://kox.moe/dl/{book.id}/{volume.id}/1/2/0/'

kmdr/module/downloader/ReferViaDownloader.py

@@ -0,0 +1,44 @@
+from kmdr.core import Downloader, VolInfo, DOWNLOADER, BookInfo
+
+from .utils import download_file, safe_filename, cached_by_kwargs
+
+try:
+    import cloudscraper
+except ImportError:
+    cloudscraper = None
+
+@DOWNLOADER.register(order=10)
+class ReferViaDownloader(Downloader):
+    def __init__(self, dest='.', callback=None, retry=3, num_workers=1, proxy=None, *args, **kwargs):
+        super().__init__(dest, callback, retry, num_workers, proxy, *args, **kwargs)
+
+        if cloudscraper:
+            self._scraper = cloudscraper.create_scraper()
+        else:
+            self._scraper = None
+
+    def _download(self, book: BookInfo, volume: VolInfo, retry: int):
+        sub_dir = safe_filename(book.name)
+        download_path = f'{self._dest}/{sub_dir}'
+
+        download_file(
+            self._session if not self._scraper else self._scraper,
+            self.fetch_download_url(book=book, volume=volume),
+            download_path,
+            f'[Kmoe][{book.name}][{volume.name}].epub',
+            retry,
+            headers={
+                "X-Km-From": "kb_http_down"
+            },
+            callback=lambda: self._callback(book, volume) if self._callback else None
+        )
+
+    @cached_by_kwargs
+    def fetch_download_url(self, book: BookInfo, volume: VolInfo) -> str:
+        response = self._session.get(f"https://kox.moe/getdownurl.php?b={book.id}&v={volume.id}&mobi=2&vip=0&json=1")
+        response.raise_for_status()
+        data = response.json()
+        if data.get('code') != 200:
+            raise Exception(f"Failed to fetch download URL: {data.get('msg', 'Unknown error')}")
+        
+        return data['url']

kmdr/module/downloader/utils.py

@@ -0,0 +1,118 @@
+from typing import Callable, Optional
+import os
+import time
+
+from requests import Session, HTTPError
+from requests.exceptions import ChunkedEncodingError
+from tqdm import tqdm
+import re
+
+BLOCK_SIZE_REDUCTION_FACTOR = 0.75
+MIN_BLOCK_SIZE = 2048
+
+def download_file(
+            session: Session, 
+            url: str,
+            dest_path: str, 
+            filename: str, 
+            retry_times: int = 0, 
+            headers: Optional[dict] = None, 
+            callback: Optional[Callable] = None,
+            block_size: int = 8192
+    ):
+    if headers is None:
+        headers = {}
+    filename_downloading = f'{filename}.downloading'
+        
+    file_path = f'{dest_path}/{filename}'
+    tmp_file_path = f'{dest_path}/{filename_downloading}'
+    
+    if not os.path.exists(dest_path):
+        os.makedirs(dest_path, exist_ok=True)
+        
+    if os.path.exists(file_path):
+        tqdm.write(f"{filename} already exists.")
+        return
+
+    resume_from = 0
+    total_size_in_bytes = 0
+    
+    if os.path.exists(tmp_file_path):
+        resume_from = os.path.getsize(tmp_file_path)
+    
+    if resume_from:
+        headers['Range'] = f'bytes={resume_from}-'
+
+    try:
+        with session.get(url = url, stream=True, headers=headers) as r:
+            r.raise_for_status()
+            
+            total_size_in_bytes = int(r.headers.get('content-length', 0)) + resume_from
+            
+            with open(tmp_file_path, 'ab') as f:
+                with tqdm(total=total_size_in_bytes, unit='B', unit_scale=True, desc=f'{filename}', initial=resume_from) as progress_bar:
+                    for chunk in r.iter_content(chunk_size=block_size):
+                        if chunk:
+                            f.write(chunk)
+                            progress_bar.update(len(chunk))
+            
+            if (os.path.getsize(tmp_file_path) == total_size_in_bytes):
+                os.rename(tmp_file_path, file_path)
+                
+                if callback:
+                    callback()
+    except Exception as e:
+        prefix = f"{type(e).__name__} occurred while downloading {filename}. "
+
+        if isinstance(e, HTTPError):
+            e.request.headers['Cookie'] = '***MASKED***'
+            tqdm.write(f"Request Headers: {e.request.headers}")
+            tqdm.write(f"Response Headers: {e.response.headers}")
+
+        new_block_size = block_size
+        if isinstance(e, ChunkedEncodingError):
+            new_block_size = max(int(block_size * BLOCK_SIZE_REDUCTION_FACTOR), MIN_BLOCK_SIZE)
+
+        if retry_times > 0:
+            # 重试下载
+            tqdm.write(f"{prefix} Retry after 3 seconds...")
+            time.sleep(3) # 等待3秒后重试，避免触发限流
+            download_file(session, url, dest_path, filename, retry_times - 1, headers, callback, new_block_size)
+        else:
+            tqdm.write(f"{prefix} Meet max retry times, download failed.")
+            raise e
+
+def safe_filename(name: str) -> str:
+    """
+    替换非法文件名字符为下划线
+    """
+    return re.sub(r'[\\/:*?"<>|]', '_', name)
+
+
+def cached_by_kwargs(func):
+    """
+    根据关键字参数缓存函数结果的装饰器。
+
+    Example:
+    >>> @kwargs_cached
+    >>> def add(a, b, c):
+    >>>     return a + b + c
+    >>> result1 = add(1, 2, c=3)  # Calls the function
+    >>> result2 = add(3, 2, c=3)  # Uses cached result
+    >>> assert result1 == result2  # Both results are the same
+    """
+    cache = {}
+
+    def wrapper(*args, **kwargs):
+        if not kwargs:
+            return func(*args, **kwargs)
+        
+        nonlocal cache
+
+        key = frozenset(kwargs.items())
+
+        if key not in cache:
+            cache[key] = func(*args, **kwargs)
+        return cache[key]
+
+    return wrapper

kmdr/module/lister/BookUrlLister.py

@@ -0,0 +1,15 @@
+from kmdr.core import Lister, LISTERS, BookInfo, VolInfo
+
+from .utils import extract_book_info_and_volumes
+
+
+@LISTERS.register()
+class BookUrlLister(Lister):
+
+    def __init__(self, book_url: str, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._book_url = book_url
+
+    def list(self) -> tuple[BookInfo, list[VolInfo]]:
+        book_info, volumes = extract_book_info_and_volumes(self._session, self._book_url)
+        return book_info, volumes

kmdr/module/lister/FollowedBookLister.py

@@ -0,0 +1,38 @@
+from bs4 import BeautifulSoup
+
+from kmdr.core import Lister, LISTERS, BookInfo, VolInfo
+
+from .utils import extract_book_info_and_volumes
+
+MY_FOLLOW_URL = 'https://kox.moe/myfollow.php'
+
+@LISTERS.register()
+class FollowedBookLister(Lister):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def list(self) -> tuple[BookInfo, list[VolInfo]]:
+        followed_rows = BeautifulSoup(self._session.get(url = MY_FOLLOW_URL).text, 'html.parser').find_all('tr', style='height:36px;')
+        mapped = map(lambda x: x.find_all('td'), followed_rows)
+        filtered = filter(lambda x: '書名' not in x[1].text, mapped)
+        books = map(lambda x: BookInfo(name = x[1].text, url = x[1].find('a')['href'], author = x[2].text, status = x[-1].text, last_update = x[-2].text, id = ''), filtered)
+        books = list(books)
+
+        print("\t最后更新时间\t书名")
+        for v in range(len(books)):
+            print(f"[{v + 1}]\t{books[v].last_update}\t{books[v].name}")
+        
+        choosed = input("choose a book to download: ")
+        while not choosed.isdigit() or int(choosed) > len(books) or int(choosed) < 1:
+            choosed = input("choose a book to download: ")
+        choosed = int(choosed) - 1
+        book = books[choosed]
+
+        book_info, volumes = extract_book_info_and_volumes(self._session, book.url)
+        book_info.author = book.author
+        book_info.status = book.status
+        book_info.last_update = book.last_update
+
+        return book_info, volumes
+        

kmdr/module/lister/utils.py

@@ -0,0 +1,79 @@
+from requests import Session
+from bs4 import BeautifulSoup
+import re
+
+from kmdr.core import BookInfo, VolInfo, VolumeType
+
+def extract_book_info_and_volumes(session: Session, url: str) -> tuple[BookInfo, list[VolInfo]]:
+    """
+    从指定的书籍页面 URL 中提取书籍信息和卷信息。
+
+    :param session: 已经建立的 requests.Session 实例。
+    :param url: 书籍页面的 URL。
+    :return: 包含书籍信息和卷信息的元组。
+    """
+    book_page = BeautifulSoup(session.get(url).text, 'html.parser')
+
+    book_info = __extract_book_info(url, book_page)
+    volumes = __extract_volumes(session, book_page)
+
+    return book_info, volumes
+
+def __extract_book_info(url: str, book_page: BeautifulSoup) -> BookInfo:
+    book_name = book_page.find('font', class_='text_bglight_big').text
+
+    id = book_page.find('input', attrs={'name': 'bookid'})['value']
+
+    return BookInfo(
+        id = id,
+        name = book_name,
+        url = url,
+        author = '',
+        status = '',
+        last_update = ''
+    )
+    
+
+def __extract_volumes(session: Session, book_page: BeautifulSoup) -> list[VolInfo]:
+    script = book_page.find_all('script', language="javascript")[-1].text
+
+    pattern = re.compile(r'/book_data.php\?h=\w+')
+    book_data_url = pattern.search(script).group(0)
+    
+    book_data = session.get(url = f"https://kox.moe{book_data_url}").text.split('\n')
+    book_data = filter(lambda x: 'volinfo' in x, book_data)
+    book_data = map(lambda x: x.split("\"")[1], book_data)
+    book_data = map(lambda x: x[8:].split(','), book_data)
+    
+    volume_data = list(map(lambda x: VolInfo(
+            id = x[0],
+            extra_info = __extract_extra_info(x[1]),
+            is_last = x[2] == '1',
+            vol_type = __extract_volume_type(x[3]),
+            index = int(x[4]),
+            pages = int(x[6]),
+            name = x[5],
+            size = float(x[11])), book_data))
+    volume_data: list[VolInfo] = volume_data
+
+    return volume_data
+
+def __extract_extra_info(value: str) -> str:
+    if value == '0':
+        return '无'
+    elif value == '1':
+        return '最近一週更新'
+    elif value == '2':
+        return '90天內曾下載/推送'
+    else:
+        return f'未知({value})'
+    
+def __extract_volume_type(value: str) -> VolumeType:
+    if value == '單行本':
+        return VolumeType.VOLUME
+    elif value == '番外篇':
+        return VolumeType.EXTRA
+    elif value == '話':
+        return VolumeType.SERIALIZED
+    else:
+        raise ValueError(f'未知的卷类型: {value}')

kmdr/module/picker/ArgsFilterPicker.py

@@ -0,0 +1,49 @@
+from typing import Optional
+
+from kmdr.core import Picker, PICKERS, VolInfo, VolumeType
+
+from .utils import resolve_volume
+
+@PICKERS.register()
+class ArgsFilterPicker(Picker):
+    """
+    通过命令行参数过滤卷信息的选择器。
+    """
+
+    def __init__(self, volume: str, vol_type: str = 'vol', max_size: Optional[float] = None, limit: Optional[int] = None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._volume = volume
+        self._vol_type = self.__get_volume_type(vol_type)
+        self._max_size: Optional[float] = max_size
+        self._limit: Optional[int] = limit
+
+    def pick(self, volumes: list[VolInfo]) -> list[VolInfo]:
+        volume_data = volumes
+
+        if self._vol_type is not None:
+            volume_data = filter(lambda x: x.vol_type == self._vol_type, volume_data)
+
+        if (choice := resolve_volume(self._volume)) is not None:
+            volume_data = filter(lambda x: x.index in choice, volume_data)
+
+        if self._max_size is not None:
+            volume_data = filter(lambda x: x.size <= self._max_size, volume_data)
+
+        if self._limit is not None:
+            return list(volume_data)[:self._limit]
+        else:
+            return list(volume_data)
+        
+    def __get_volume_type(self, vol_type: str) -> Optional[VolumeType]:
+        assert vol_type in {'vol', 'extra', 'seri', 'all'}, f"Invalid volume type: {vol_type}"
+
+        if vol_type == 'vol':
+            return VolumeType.VOLUME
+        elif vol_type == 'extra':
+            return VolumeType.EXTRA
+        elif vol_type == 'seri':
+            return VolumeType.SERIALIZED
+        elif vol_type == 'all':
+            return None
+        else:
+            raise ValueError(f"Unknown volume type: {vol_type}")

kmdr/module/picker/DefaultVolPicker.py

@@ -0,0 +1,21 @@
+from kmdr.core import Picker, PICKERS, VolInfo
+
+from .utils import resolve_volume
+
+@PICKERS.register()
+class DefaultVolPicker(Picker):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def pick(self, volumes: list[VolInfo]) -> list[VolInfo]:
+        print("\t卷类型\t页数\t大小(MB)\t卷名")
+        for index, volume in enumerate(volumes):
+            print(f"[{index + 1}]\t{volume.vol_type.value}\t{volume.pages}\t{volume.size:.2f}\t\t{volume.name}")
+
+        choosed = input("choose a volume to download (e.g. 'all', '1,2,3', '1-3,4-6'):\n")
+
+        if (chosen := resolve_volume(choosed)) is None:
+            return volumes
+
+        return [volumes[i - 1] for i in chosen if 1 <= i <= len(volumes)]

kmdr/module/picker/utils.py

@@ -0,0 +1,37 @@
+from typing import Optional
+
+def resolve_volume(volume: str) -> Optional[set[int]]:
+    if volume == 'all':
+        return None
+
+    if ',' in volume:
+        # 如果使用分隔符
+        volumes = volume.split(',')
+        volumes = [resolve_volume(v) for v in volumes]
+
+        ret = set()
+        for v in volumes:
+            if v is not None:
+                ret.update(v)
+
+        return ret
+
+    if (volume := volume.strip()).isdigit():
+        # 只有一个数字
+        assert (volume := int(volume)) > 0, "Volume number must be greater than 0."
+        return {volume}
+    elif '-' in volume and volume.count('-') == 1 and ',' not in volume:
+        # 使用了范围符号
+        start, end = volume.split('-')
+
+        assert start.strip().isdigit() and end.strip().isdigit(), "Invalid range format. Use 'start-end' or 'start, end'."
+
+        start = int(start.strip())
+        end = int(end.strip())
+
+        assert start > 0 and end > 0, "Volume numbers must be greater than 0."
+        assert start <= end, "Start of range must be less than or equal to end."
+
+        return set(range(start, end + 1))
+
+    raise ValueError(f"Invalid volume format: {volume}. Use 'all', '1,2,3', '1-3', or '1-3,4-6'.")