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

kmdr/core/__init__.py

@@ -0,0 +1,5 @@
+from .bases import Authenticator, Lister, Picker, Downloader, Configurer
+from .structure import VolInfo, BookInfo, VolumeType
+from .bases import AUTHENTICATOR, LISTERS, PICKERS, DOWNLOADER, CONFIGURER
+
+from .defaults import argument_parser

kmdr/core/bases.py

@@ -0,0 +1,113 @@
+import os
+
+from typing import Callable, Optional
+
+from .registry import Registry
+from .structure import VolInfo, BookInfo
+from .utils import get_singleton_session, construct_callback
+from .defaults import Configurer as InnerConfigurer
+
+class SessionContext:
+
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        self._session = get_singleton_session()
+
+class ConfigContext:
+
+    def __init__(self, *args, **kwargs):
+        super().__init__()
+        self._configurer = InnerConfigurer()
+
+class Configurer(ConfigContext):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+    
+    def operate(self) -> None: ...
+
+class Authenticator(SessionContext, ConfigContext):
+
+    def __init__(self, proxy: Optional[str] = None, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        if proxy:
+            self._session.proxies.update({
+                'https': proxy,
+                'http': proxy,
+            })
+
+    # 在使用代理登录时，可能会出现问题，但是现在还不清楚是不是代理的问题。
+    # 主站正常情况下不使用代理也能登录成功。但是不排除特殊的网络环境下需要代理。
+    # 所以暂时保留代理登录的功能，如果后续确认是代理的问题，可以考虑启用 @no_proxy 装饰器。
+    # @no_proxy
+    def authenticate(self) -> bool:
+        return self._authenticate()
+
+    def _authenticate(self) -> bool: ...
+
+class Lister(SessionContext):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def list(self) -> tuple[BookInfo, list[VolInfo]]: ...
+
+class Picker(SessionContext):
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+    def pick(self, volumes: list[VolInfo]) -> list[VolInfo]: ...
+
+class Downloader(SessionContext):
+
+    def __init__(self, 
+            dest: str = '.',
+            callback: Optional[str] = None,
+            retry: int = 3,
+            num_workers: int = 1,
+            proxy: Optional[str] = None,
+            *args, **kwargs
+    ):
+        super().__init__(*args, **kwargs)
+        self._dest: str = dest
+        self._callback: Optional[Callable[[BookInfo, VolInfo], int]] = construct_callback(callback)
+        self._retry: int = retry
+        self._num_workers: int = num_workers
+
+        if proxy:
+            self._session.proxies.update({
+                'https': proxy,
+                'http': proxy,
+            })
+
+    def download(self, book: BookInfo, volumes: list[VolInfo]):
+        if volumes is None or not volumes:
+            raise ValueError("No volumes to download")
+
+        if self._num_workers <= 1:
+            for volume in volumes:
+                self._download(book, volume, self._retry)
+        else:
+            self._download_with_multiple_workers(book, volumes, self._retry)
+
+    def _download(self, book: BookInfo, volume: VolInfo, retry: int): ...
+
+    def _download_with_multiple_workers(self, book: BookInfo, volumes: list[VolInfo], retry: int):
+        from concurrent.futures import ThreadPoolExecutor
+
+        max_workers = min(self._num_workers, len(volumes))
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            futures = [
+                executor.submit(self._download, book, volume, retry)
+                for volume in volumes
+            ]
+            for future in futures:
+                future.result()
+
+AUTHENTICATOR = Registry[Authenticator]('Authenticator')
+LISTERS = Registry[Lister]('Lister')
+PICKERS = Registry[Picker]('Picker')
+DOWNLOADER = Registry[Downloader]('Downloader', True)
+CONFIGURER = Registry[Configurer]('Configurer')

kmdr/core/defaults.py

@@ -0,0 +1,154 @@
+import os
+import json
+from typing import Optional
+import argparse
+
+from .utils import singleton
+from .structure import Config
+
+parser: Optional[argparse.ArgumentParser] = None
+args: Optional[argparse.Namespace] = None
+
+def argument_parser():
+    global parser
+    if parser is not None:
+        return parser
+
+    parser = argparse.ArgumentParser(description='Kox Downloader')
+    subparsers = parser.add_subparsers(title='subcommands', dest='command')
+
+    download_parser = subparsers.add_parser('download', help='Download books')
+    download_parser.add_argument('-d', '--dest', type=str, help='Download destination, default to current directory', required=False)
+    download_parser.add_argument('-l', '--book-url', type=str, help='Book page\'s url', required=False)
+    download_parser.add_argument('-v', '--volume', type=str, help='Volume(s), split using commas, `all` for all', required=False)
+    download_parser.add_argument('-t', '--vol-type', type=str, help='Volume type, `vol` for volume, `extra` for extras, `seri` for serialized', required=False, choices=['vol', 'extra', 'seri', 'all'], default='vol')
+    download_parser.add_argument('--max-size', type=float, help='Max size of volume in MB', required=False)
+    download_parser.add_argument('--limit', type=int, help='Limit number of volumes to download', required=False)
+    download_parser.add_argument('--num-workers', type=int, help='Number of workers to use for downloading', required=False)
+    download_parser.add_argument('-p', '--proxy', type=str, help='Proxy server', required=False)
+    download_parser.add_argument('-r', '--retry', type=int, help='Retry times', required=False)
+    download_parser.add_argument('-c', '--callback', type=str, help='Callback script, use as `echo {v.name} downloaded!`', required=False)
+
+    login_parser = subparsers.add_parser('login', help='Login to kox.moe')
+    login_parser.add_argument('-u', '--username', type=str, help='Your username', required=True)
+    login_parser.add_argument('-p', '--password', type=str, help='Your password', required=False)
+
+    status_parser = subparsers.add_parser('status', help='Show status of account and script')
+    status_parser.add_argument('-p', '--proxy', type=str, help='Proxy server', required=False)
+
+    config_parser = subparsers.add_parser('config', help='Configure the downloader')
+    config_parser.add_argument('-l', '--list-option', action='store_true', help='List all configurations')
+    config_parser.add_argument('-s', '--set', nargs='+', type=str, help='Configuration options to set, e.g. num_workers=3 dest=.')
+    config_parser.add_argument('-c', '--clear', type=str, help='Clear configurations, `all`, `cookie`, `option` are available')
+    config_parser.add_argument('-d', '--delete', '--unset', dest='unset', type=str, help='Delete a specific configuration option')
+
+    return parser
+
+def parse_args():
+    global args
+    if args is not None:
+        return args
+
+    parser = argument_parser()
+    args = parser.parse_args()
+
+    if args.command is None:
+        parser.print_help()
+        exit(1)
+
+    return args
+
+@singleton
+class Configurer:
+
+    def __init__(self):
+        self.__filename = '.kmdr'
+
+        if not os.path.exists(os.path.join(os.path.expanduser("~"), self.__filename)):
+            self._config = Config()
+            self.update()
+        else:
+            with open(os.path.join(os.path.expanduser("~"), self.__filename), 'r') as f:
+                config = json.load(f)
+
+            self._config = Config()
+            option = config.get('option', None)
+            if option is not None and isinstance(option, dict):
+                self._config.option = option
+            cookie = config.get('cookie', None)
+            if cookie is not None and isinstance(cookie, dict):
+                self._config.cookie = cookie
+
+    @property
+    def config(self) -> 'Config':
+        return self._config
+    
+    @property
+    def cookie(self) -> Optional[dict]:
+        if self._config is None:
+            return None
+        return self._config.cookie
+    
+    @cookie.setter
+    def cookie(self, value: Optional[dict[str, str]]):
+        if self._config is None:
+            self._config = Config()
+        self._config.cookie = value
+        self.update()
+    
+    @property
+    def option(self) -> Optional[dict]:
+        if self._config is None:
+            return None
+        return self._config.option
+    
+    @option.setter
+    def option(self, value: Optional[dict[str, any]]):
+        if self._config is None:
+            self._config = Config()
+        self._config.option = value
+        self.update()
+    
+    def update(self):
+        with open(os.path.join(os.path.expanduser("~"), self.__filename), 'w') as f:
+            json.dump(self._config.__dict__, f, indent=4, ensure_ascii=False)
+    
+    def clear(self, key: str):
+        if key == 'all':
+            self._config = Config()
+        elif key == 'cookie':
+            self._config.cookie = None
+        elif key == 'option':
+            self._config.option = None
+        else:
+            raise ValueError(f"Unsupported clear option: {key}")
+
+        self.update()
+    
+    def set_option(self, key: str, value: any):
+        if self._config.option is None:
+            self._config.option = {}
+
+        self._config.option[key] = value
+        self.update()
+    
+    def unset_option(self, key: str):
+        if self._config.option is None or key not in self._config.option:
+            return
+        
+        del self._config.option[key]
+        self.update()
+
+def __combine_args(dest: argparse.Namespace, option: dict) -> argparse.Namespace:
+    if option is None:
+        return dest
+
+    for key, value in option.items():
+        if hasattr(dest, key) and getattr(dest, key) is None:
+            setattr(dest, key, value)
+    return dest
+
+def combine_args(dest: argparse.Namespace) -> argparse.Namespace:
+    assert isinstance(dest, argparse.Namespace), "dest must be an argparse.Namespace instance"
+    option = Configurer().config.option
+    return __combine_args(dest, option)

kmdr/core/registry.py

@@ -0,0 +1,128 @@
+from typing import Optional, Callable, TypeVar, Generic
+from dataclasses import dataclass, field
+from argparse import Namespace
+
+from .defaults import combine_args
+
+T = TypeVar('T')
+
+class Registry(Generic[T]):
+
+    def __init__(self, name: str, combine_args: bool = False):
+        self._name = name
+        self._modules: list['Predication'] = list()
+        self._combine_args = combine_args
+
+    def register(self,
+            hasattrs: frozenset[str] = frozenset(),
+            containattrs: frozenset[str] = frozenset(),
+            hasvalues: dict[str, object] = dict(),
+            predicate: Optional[Callable[[Namespace], bool]] = None,
+            order: int = 0,
+            name: Optional[str] = None
+    ):
+        """
+        注册一个模块到注册表中。
+        总体的匹配逻辑: `{predicate} or {hasvalues} and ({hasattrs} or {containattrs})`
+
+        :param hasattrs: 模块处理的参数集合，必须全部匹配。如果未提供，则从类的 __init__ 方法中获取不可缺省的参数
+        :param containattrs: 模块处理的可选参数集合，只要满足其中一个即可。
+        :param hasvalues: 模块处理的属性值集合，必须全部满足。
+        :param predicate: 可以提供预定义以外的条件，只要满足该条件就视为匹配。
+        :param order: 模块的优先级，数字越小优先级越高。
+        :param name: 模块的名称，如果未提供，则使用类名。
+        """
+
+        def wrapper(cls):
+            nonlocal hasattrs
+            nonlocal containattrs
+            nonlocal hasvalues
+            nonlocal name
+            nonlocal predicate
+
+            if name is None:
+                name = cls.__name__
+
+            if not hasattrs or len(hasattrs) == 0:
+                # 如果没有指定属性，则从类的 __init__ 方法中获取参数
+                if hasattr(cls, '__init__'):
+                    init_signature = cls.__init__.__code__.co_varnames[1:cls.__init__.__code__.co_argcount]
+                    init_defaults = cls.__init__.__defaults__ or ()
+                    default_count = len(init_defaults)
+                    required_params = init_signature[:len(init_signature) - default_count]
+                    hasattrs = frozenset(required_params)
+                else:
+                    raise ValueError(f'{self._name} requires at least one attribute to be specified for {name}')
+            
+            predication = Predication(
+                cls=cls,
+                hasattrs=frozenset(hasattrs),
+                containattrs=frozenset(containattrs),
+                hasvalues=hasvalues,
+                predicate=predicate,
+                order=order
+            )
+
+            if predication in self._modules:
+                raise ValueError(f'{self._name} already has a module for {predication}')
+            
+            self._modules.append(predication)
+            self._modules.sort()
+
+            return cls
+        
+        return wrapper
+    
+    def get(self, condition: Namespace) -> T:
+        if self._combine_args:
+            condition = combine_args(condition)
+        return self._get(condition)
+    
+    def _get(self, condition: Namespace) -> T:
+        if not self._modules or len(self._modules) == 0:
+            raise ValueError(f'{self._name} has no registered modules')
+
+        if len(self._modules) == 1:
+            return self._modules[0].cls(**self._filter_nonone_args(condition))
+        
+        for module in self._modules:
+            if (module.predicate is not None and module.predicate(condition)) or \
+                    all(hasattr(condition, attr) and getattr(condition, attr) == value for attr, value in module.hasvalues.items()) and \
+                    (all(hasattr(condition, attr) and getattr(condition, attr) is not None for attr in module.hasattrs) \
+                            or any(hasattr(condition, attr) for attr in module.containattrs)):
+
+                # 手动配置的 predicate 优先级最高，只要满足 predicate 条件就返回
+                # hasvalues 配置的属性值必须完全匹配
+                # hasattrs 和 containattrs 二者只需要满足一个
+                
+                return module.cls(**self._filter_nonone_args(condition))
+
+        raise ValueError(f'{self._name} does not have a module for {condition}')
+    
+    def _filter_nonone_args(self, condition: Namespace) -> dict[str, object]:
+        return {k: v for k, v in vars(condition).items() if v is not None}
+
+@dataclass(frozen=True)
+class Predication:
+    cls: type
+
+    hasattrs: frozenset[str] = frozenset({})
+    containattrs: frozenset[str] = frozenset({})
+    hasvalues: dict[str, object] = field(default_factory=dict)
+    predicate: Optional[Callable[[Namespace], bool]] = None
+
+    order: int = 0
+
+    def __lt__(self, other: 'Predication') -> bool:
+        if self.order == other.order:
+            # 如果 order 相同，则比较 hasattrs 的长度
+            # 通常情况下，hasattrs 的长度越长，优先级越高
+            return len(self.hasattrs) > len(other.hasattrs)
+        return self.order < other.order
+    
+    def __hash__(self) -> int:
+        return hash((self.cls, self.hasattrs, frozenset(self.hasvalues.items()), self.predicate, self.order))
+    
+    def __eq__(self, other: 'Predication') -> bool:
+        return (self.cls, self.hasattrs, frozenset(self.hasvalues.items()), self.predicate, self.order) == \
+               (other.cls, other.hasattrs, frozenset(other.hasvalues.items()), other.predicate, other.order)

kmdr/core/structure.py

@@ -0,0 +1,68 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+class VolumeType(Enum):
+    VOLUME = "單行本"
+    EXTRA = "番外篇"
+    SERIALIZED = "連載話"
+
+@dataclass(frozen=True)
+class VolInfo:
+    """
+    Kmoe 卷信息
+    """
+
+    id: str
+
+    extra_info: str
+    """
+    额外信息
+    - 0: 无
+    - 1: 最近一週更新
+    - 2: 90天內曾下載/推送
+    """
+
+    is_last: bool
+
+    vol_type: VolumeType
+
+    index: int
+    """
+    从1开始的卷索引
+    如果卷类型为「連載話」，则表示起始话数
+    """
+
+    name: str
+
+    pages: int
+
+    size: float
+    """
+    卷大小，单位为MB
+    """
+
+
+@dataclass(frozen=True)
+class BookInfo:
+    id: str
+    name: str
+    url: str
+    author: str
+    status: str
+    last_update: str
+
+@dataclass
+class Config:
+
+    option: Optional[dict] = None
+    """
+    用来存储下载相关的配置选项
+    - retry_times: 重试次数
+    - dest: 下载文件保存路径
+    - callback: 下载完成后的回调函数
+    - proxy: 下载时使用的代理
+    - num_workers: 下载时使用的线程数
+    """
+
+    cookie: Optional[dict[str, str]] = None

kmdr/core/utils.py

@@ -0,0 +1,77 @@
+import functools
+from typing import Optional, Callable
+
+from requests import Session
+import threading
+import subprocess
+
+from .structure import BookInfo, VolInfo
+
+_session_instance: Optional[Session] = None
+
+_session_lock = threading.Lock()
+
+HEADERS = {
+    'User-Agent': 'kmdr/1.0 (https://github.com/chrisis58/kmoe-manga-downloader)'
+}
+
+def get_singleton_session() -> Session:
+    global _session_instance
+
+    if _session_instance is None:
+        with _session_lock:
+            if _session_instance is None:
+                _session_instance = Session()
+                _session_instance.headers.update(HEADERS)
+
+    return _session_instance
+
+def clear_session_context():
+    session = get_singleton_session()
+    session.proxies.clear()
+    session.headers.clear()
+    session.cookies.clear()
+    session.headers.update(HEADERS)
+
+def singleton(cls):
+    """
+    **非线程安全**的单例装饰器
+    """
+
+    instances = {}
+
+    def get_instance(*args, **kwargs):
+        if cls not in instances:
+            instances[cls] = cls(*args, **kwargs)
+        return instances[cls]
+
+    return get_instance
+
+def construct_callback(callback: Optional[str]) -> Optional[Callable]:
+    if callback is None or not isinstance(callback, str) or not callback.strip():
+        return None
+
+    def _callback(book: BookInfo, volume: VolInfo) -> int:
+        nonlocal callback
+
+        assert callback, "Callback script cannot be empty"
+        formatted_callback = callback.strip().format(b=book, v=volume)
+
+        return subprocess.run(formatted_callback, shell=True, check=True).returncode
+
+    return _callback
+
+def no_proxy(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        session = get_singleton_session()
+
+        cached_proxies = session.proxies.copy()
+        session.proxies.clear()
+
+        try:
+            return func(*args, **kwargs)
+        finally:
+            session.proxies = cached_proxies
+
+    return wrapper

kmdr/main.py

@@ -0,0 +1,39 @@
+from typing import Callable
+from argparse import Namespace
+
+from kmdr.core import *
+from kmdr.module import *
+
+def main(args: Namespace, fallback: Callable[[], None] = lambda: print('NOT IMPLEMENTED!')) -> None:
+
+    if args.command == 'login':
+        if not AUTHENTICATOR.get(args).authenticate():
+            raise RuntimeError("Authentication failed. Please check your credentials.")
+
+    elif args.command == 'status':
+        if not AUTHENTICATOR.get(args).authenticate():
+            raise RuntimeError("Authentication failed. Please check your credentials.")
+
+    elif args.command == 'download':    
+        if not AUTHENTICATOR.get(args).authenticate():
+            raise RuntimeError("Authentication failed. Please check your credentials.")
+
+        book, volumes = LISTERS.get(args).list()
+
+        volumes = PICKERS.get(args).pick(volumes)
+
+        DOWNLOADER.get(args).download(book, volumes)
+
+    elif args.command == 'config':
+        CONFIGURER.get(args).operate()
+
+    else:
+        fallback()
+
+def entry_point():
+    parser = argument_parser()
+    args = parser.parse_args()
+    main(args, lambda: parser.print_help())
+
+if __name__ == '__main__':
+    entry_point()

kmdr/module/__init__.py

@@ -0,0 +1,5 @@
+from .authenticator import CookieAuthenticator, LoginAuthenticator
+from .lister import BookUrlLister, FollowedBookLister
+from .picker import ArgsFilterPicker, DefaultVolPicker
+from .downloader import DirectDownloader, ReferViaDownloader
+from .configurer import OptionLister, OptionSetter, ConfigClearer, ConfigUnsetter

kmdr/module/authenticator/CookieAuthenticator.py

@@ -0,0 +1,25 @@
+from typing import Optional
+
+from kmdr.core import Authenticator, AUTHENTICATOR
+
+from .utils import check_status
+
+@AUTHENTICATOR.register()
+class CookieAuthenticator(Authenticator):
+    def __init__(self, proxy: Optional[str] = None, *args, **kwargs):
+        super().__init__(proxy, *args, **kwargs)
+
+        if 'command' in kwargs and kwargs['command'] == 'status':
+            self._show_quota = True
+        else:
+            self._show_quota = False
+
+    def _authenticate(self) -> bool:
+        cookie = self._configurer.cookie
+        
+        if not cookie:
+            print("No cookie found. Please login first.")
+            return False
+        
+        self._session.cookies.update(cookie)
+        return check_status(self._session, show_quota=self._show_quota)

kmdr/module/authenticator/LoginAuthenticator.py

@@ -0,0 +1,54 @@
+from typing import Optional
+import re
+
+from kmdr.core import Authenticator, AUTHENTICATOR
+
+from .utils import check_status
+
+
+@AUTHENTICATOR.register(
+    hasvalues = {'command': 'login'}
+)
+class LoginAuthenticator(Authenticator):
+    def __init__(self, username: str, proxy: Optional[str] = None, password: Optional[str] = None, show_quota = True, *args, **kwargs):
+        super().__init__(proxy, *args, **kwargs)
+        self._username = username
+        self._show_quota = show_quota
+
+        if password is None:
+            password = input("please input your password: \n")
+
+        self._password = password
+
+    def _authenticate(self) -> bool:
+        
+        response = self._session.post(
+            url = 'https://kox.moe/login_do.php', 
+            data = {
+                'email': self._username,
+                'passwd': self._password,
+                'keepalive': 'on'
+            },
+        )
+        response.raise_for_status()
+        
+        match = re.search('"\w+"', response.text)
+        if not match:
+            raise RuntimeError("Failed to extract authentication code from response.")
+        code = match.group(0).split('"')[1]
+        if code != 'm100':
+            if code == 'e400':
+                print("帳號或密碼錯誤。")
+            elif code == 'e401':
+                print("非法訪問，請使用瀏覽器正常打開本站")
+            elif code == 'e402':
+                print("帳號已經註銷。不會解釋原因，無需提問。")
+            elif code == 'e403':
+                print("驗證失效，請刷新頁面重新操作。")
+            raise RuntimeError("Authentication failed with code: " + code)
+        
+        if check_status(self._session, show_quota=self._show_quota):
+            self._configurer.cookie = self._session.cookies.get_dict()
+            return True
+        
+        return False