ddns 4.1.0b4__tar.gz → 4.1.1b2__tar.gz

{ddns-4.1.0b4 → ddns-4.1.1b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddns
-Version: 4.1.0b4
+Version: 4.1.1b2
 Summary: Dynamic DNS client for multiple providers, supporting IPv4 and IPv6.
 Author-email: NewFuture <python@newfuture.cc>
 License-Expression: MIT

{ddns-4.1.0b4 → ddns-4.1.1b2}/ddns/__init__.py

@@ -6,7 +6,7 @@ ddns Package
 __description__ = "automatically update DNS records to my IP [域名自动指向本机IP]"
 
 # 编译时，版本会被替换
-__version__ = "4.1.0b4"
+__version__ = "4.1.1b2"
 
 # 时间也会被替换掉
-build_date = "2025-08-16T02:41:26Z"
+build_date = "2025-10-27T04:09:37Z"

{ddns-4.1.0b4 → ddns-4.1.1b2}/ddns/__main__.py

@@ -68,7 +68,7 @@ def update_ip(dns, cache, index_rule, domains, record_type, config):
             update_success = True
         else:
             try:
-                result = dns.set_record(domain, address, record_type=record_type, ttl=config.ttl, line=config.line)
+                result = dns.set_record(domain, address, record_type=record_type, ttl=config.ttl, line=config.line, **config.extra)
                 if result:
                     logger.warning("set %s[IPv%s]: %s successfully.", domain, ip_type, address)
                     update_success = True
@@ -92,7 +92,12 @@ def run(config):
     # dns provider class
     provider_class = get_provider_class(config.dns)
     dns = provider_class(
-        config.id, config.token, endpoint=config.endpoint, logger=logger, proxy=config.proxy, ssl=config.ssl
+        config.id,
+        config.token,
+        endpoint=config.endpoint,
+        logger=logger,
+        proxy=config.proxy,
+        ssl=config.ssl,
     )
     cache = Cache.new(config.cache, config.md5(), logger)
     return (

ddns-4.1.1b2/ddns/config/__init__.py

@@ -0,0 +1,171 @@
+# -*- coding:utf-8 -*-
+"""
+Configuration loader for DDNS.
+
+This module handles loading configuration from command-line arguments,
+JSON configuration files, and environment variables.
+
+@author: NewFuture
+"""
+
+import os
+import sys
+import logging
+from .cli import load_config as load_cli_config
+from .file import load_config as load_file_config, save_config
+from .env import load_config as load_env_config
+from .config import Config, split_array_string
+
+
+def _get_config_paths(config_paths):
+    # type: (list[str] | None) -> list[str]
+    """
+    获取配置文件路径列表，支持多个配置文件
+    """
+    if not config_paths:
+        # Find config file in default locations
+        for p in [
+            "config.json",
+            os.path.expanduser("~/.ddns/config.json"),
+            os.path.expanduser("~/.ddns.json"),
+            "/etc/ddns/config.json",
+            "/etc/ddns.json",
+        ]:
+            if os.path.exists(p):
+                return [p]
+        return []
+
+    # 验证所有路径都存在（跳过URL检查）
+    for config_path in config_paths:
+        # 跳过远程URL的存在性检查
+        if "://" not in config_path and not os.path.exists(config_path):
+            sys.stderr.write("Config file `%s` does not exist!\n" % config_path)
+            sys.stdout.write("Please check the path or use `--new-config` to create new one.\n")
+            sys.exit(1)
+
+    return config_paths
+
+
+def _setup_logging(cli_config, env_config, all_json_configs):
+    # type: (dict, dict, list[dict]) -> logging.Logger
+    """Setup logging configuration and return logger."""
+    # Use first config for global log settings (log config is inherited from global in v4.1 format)
+    json_config = all_json_configs[0] if all_json_configs else {}
+    global_conf = Config(cli_config=cli_config, json_config=json_config, env_config=env_config)
+    log_format = global_conf.log_format  # type: str  # type: ignore
+    if log_format:
+        # A custom log format is already set; no further action is required.
+        pass
+    elif global_conf.log_level < logging.INFO:
+        # Override log format in debug mode to include filename and line number for detailed debugging
+        log_format = "%(asctime)s %(levelname)s [%(name)s.%(funcName)s](%(filename)s:%(lineno)d): %(message)s"
+    elif global_conf.log_level > logging.INFO:
+        log_format = "%(asctime)s %(levelname)s: %(message)s"
+    else:
+        log_format = "%(asctime)s %(levelname)s [%(name)s]: %(message)s"
+    logging.basicConfig(
+        level=global_conf.log_level, format=log_format, datefmt=global_conf.log_datefmt, filename=global_conf.log_file
+    )
+    return logging.getLogger().getChild("config")  # type: logging.Logger
+
+
+def _load_json_configs(config_paths, proxy, ssl):
+    # type: (list[str], list[str], str) -> list[dict]
+    """Load all JSON configurations from config paths."""
+    all_json_configs = []
+    for config_path in config_paths:
+        json_configs = load_file_config(config_path, proxy=proxy, ssl=ssl)
+        if isinstance(json_configs, list):
+            all_json_configs.extend(json_configs)
+        else:
+            all_json_configs.append(json_configs)
+
+    # 如果没有找到任何配置文件或JSON配置，创建一个空配置
+    return all_json_configs or [{}]
+
+
+def _validate_configs(configs, logger):
+    # type: (list[Config], logging.Logger) -> None
+    """Validate that all configs have DNS providers."""
+    for i, conf in enumerate(configs):
+        if not conf.dns:
+            logger.critical(
+                "No DNS provider specified in config %d! Please set `dns` in config or use `--dns` CLI option.", i + 1
+            )
+            sys.exit(2)
+
+
+def load_configs(description, version, date):
+    # type: (str, str, str) -> list[Config]
+    """
+    Load and merge configuration from CLI, JSON, and environment variables.
+    Supports multiple config files and array config formats.
+
+    This function loads configuration from all three sources and returns a
+    list of Config objects that provides easy access to merged configuration values.
+
+    Args:
+        description (str): The program description for the CLI parser.
+        version (str): The program version for the CLI parser.
+        date (str): The program release date for the CLI parser.
+
+    Returns:
+        list[Config]: A list of Config objects with merged configuration from all sources.
+    """
+    doc = """
+ddns [v{version}@{date}]
+(i) homepage or docs [文档主页]: https://ddns.newfuture.cc/
+(?) issues or bugs [问题和反馈]: https://github.com/NewFuture/DDNS/issues
+Copyright (c) NewFuture (MIT License)
+""".format(version=version, date=date)
+    # Load CLI configuration first
+    cli_config = load_cli_config(description, doc, version, date)
+    env_config = load_env_config()
+
+    # 获取配置文件路径列表
+    config_paths = split_array_string(cli_config.get("config", env_config.get("config", [])))
+    config_paths = _get_config_paths(config_paths)
+
+    # 提取代理和SSL设置用于HTTP请求
+    proxy_settings = split_array_string(cli_config.get("proxy", env_config.get("proxy", [])))  # type: list[str]
+    ssl_settings = cli_config.get("ssl", env_config.get("ssl", "auto"))
+
+    # 加载所有配置文件
+    all_json_configs = _load_json_configs(config_paths, proxy_settings, ssl_settings)
+
+    # 为每个JSON配置创建Config对象
+    configs = [
+        Config(cli_config=cli_config, json_config=json_config, env_config=env_config)
+        for json_config in all_json_configs
+    ]
+
+    # 设置日志
+    logger = _setup_logging(cli_config, env_config, all_json_configs)
+
+    # 处理无配置情况 - inline _handle_no_config logic
+    if len(cli_config) <= 1 and len(all_json_configs) == 1 and not all_json_configs[0] and not env_config:
+        # 没有配置时生成默认配置文件
+        logger.warning("[deprecated] auto gernerate config file will be deprecated in future versions.")
+        logger.warning("usage:\n  `ddns --new-config` to generate a new config.\n  `ddns -h` for help.")
+        default_config_path = config_paths[0] if config_paths else "config.json"
+        save_config(default_config_path, cli_config)
+        logger.info("No config file found, generated default config at `%s`.", default_config_path)
+        sys.exit(1)
+
+    # 记录配置加载情况
+    if config_paths:
+        logger.info("load config: %s", config_paths)
+    else:
+        logger.debug("No config file specified, using CLI and environment variables only.")
+
+    # 仅在没有配置文件且开启debug时自动设置debug provider
+    if not config_paths and cli_config.get("debug") and len(configs) == 1 and not configs[0].dns:
+        configs[0].dns = "debug"
+
+    # 验证每个配置都有DNS provider
+    _validate_configs(configs, logger)
+
+    return configs
+
+
+__all__ = ["load_configs", "Config"]

ddns-4.1.1b2/ddns/config/cli.py

@@ -0,0 +1,366 @@
+# -*- coding:utf-8 -*-
+"""
+Configuration loader for DDNS command-line interface.
+@author: NewFuture
+"""
+
+import platform
+import sys
+from argparse import SUPPRESS, Action, ArgumentParser, RawTextHelpFormatter
+from logging import DEBUG, basicConfig, getLevelName
+from os import path as os_path
+
+from ..scheduler import get_scheduler
+from .file import save_config
+
+__all__ = ["load_config", "str_bool"]
+
+
+def str_bool(v):
+    # type: (str | bool | None | int | float | list) -> bool | str
+    """
+    parse string to boolean
+    """
+    if isinstance(v, bool):
+        return v
+    if v is None:
+        return False
+    if not isinstance(v, str) and not type(v).__name__ == "unicode":
+        return bool(v)  # For non-string types, convert to string first
+    if v.lower() in ("yes", "true", "t", "y", "1"):  # type: ignore[attribute-defined]
+        return True
+    elif v.lower() in ("no", "false", "f", "n", "0"):  # type: ignore[attribute-defined]
+        return False
+    else:
+        return v  # type: ignore[return-value]
+
+
+def log_level(value):
+    """
+    parse string to log level
+    or getattr(logging, value.upper())
+    """
+    return getLevelName(value if isinstance(value, int) else value.upper())
+
+
+def _get_system_info_str():
+    system = platform.system()
+    release = platform.release()
+    machine = platform.machine()
+    arch = platform.architecture()
+    return "{}-{} {} {}".format(system, release, machine, arch)
+
+
+def _get_python_info_str():
+    version = platform.python_version()
+    branch, py_build_date = platform.python_build()
+    return "Python-{} {} ({})".format(version, branch, py_build_date)
+
+
+class ExtendAction(Action):
+    """兼容 Python <3.8 的 extend action"""
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        items = getattr(namespace, self.dest, None)
+        if items is None:
+            items = []
+        # values 可能是单个值或列表
+        if isinstance(values, list):
+            items.extend(values)
+        else:
+            items.append(values)
+        setattr(namespace, self.dest, items)
+
+
+class NewConfigAction(Action):
+    """生成配置文件并退出程序"""
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        # 获取配置文件路径
+        if values and values != "true":
+            config_path = str(values)  # type: str
+        else:
+            config_path = getattr(namespace, "config", None) or "config.json"  # type: str
+            config_path = config_path[0] if isinstance(config_path, list) else config_path
+            if os_path.exists(config_path):
+                sys.stderr.write("The default %s already exists!\n" % config_path)
+                sys.stdout.write("Please use `--new-config=%s` to specify a new config file.\n" % config_path)
+                sys.exit(1)
+        # 获取当前已解析的参数
+        current_config = {k: v for k, v in vars(namespace).items() if v is not None}
+        # 保存配置文件
+        save_config(config_path, current_config)
+        sys.stdout.write("%s is generated.\n" % config_path)
+        sys.exit(0)
+
+
+def _add_ddns_args(arg):  # type: (ArgumentParser) -> None
+    """Add common DDNS arguments to a parser"""
+    log_levels = [
+        "CRITICAL",  # 50
+        "ERROR",  # 40
+        "WARNING",  # 30
+        "INFO",  # 20
+        "DEBUG",  # 10
+        "NOTSET",  # 0
+    ]
+    arg.add_argument(
+        "-c",
+        "--config",
+        nargs="*",
+        action=ExtendAction,
+        metavar="FILE",
+        help="load config file [配置文件路径, 可多次指定]",
+    )
+    arg.add_argument("--debug", action="store_true", help="debug mode [开启调试模式]")
+
+    # DDNS Configuration group
+    ddns = arg.add_argument_group("DDNS Configuration [DDNS配置参数]")
+    ddns.add_argument(
+        "--dns",
+        help="DNS provider [DNS服务提供商]",
+        choices=[
+            "51dns",
+            "alidns",
+            "aliesa",
+            "callback",
+            "cloudflare",
+            "debug",
+            "dnscom",
+            "dnspod_com",
+            "dnspod",
+            "edgeone",
+            "he",
+            "huaweidns",
+            "namesilo",
+            "noip",
+            "tencentcloud",
+        ],
+    )
+    ddns.add_argument("--id", help="API ID or email [对应账号ID或邮箱]")
+    ddns.add_argument("--token", help="API token or key [授权凭证或密钥]")
+    ddns.add_argument("--endpoint", help="API endpoint URL [API端点URL]")
+    ddns.add_argument(
+        "--index4", nargs="*", action=ExtendAction, metavar="RULE", help="IPv4 rules [获取IPv4方式, 多次可配置多规则]"
+    )
+    ddns.add_argument(
+        "--index6", nargs="*", action=ExtendAction, metavar="RULE", help="IPv6 rules [获取IPv6方式, 多次配置多规则]"
+    )
+    ddns.add_argument(
+        "--ipv4", nargs="*", action=ExtendAction, metavar="DOMAIN", help="IPv4 domains [IPv4域名列表, 可配多个域名]"
+    )
+    ddns.add_argument(
+        "--ipv6", nargs="*", action=ExtendAction, metavar="DOMAIN", help="IPv6 domains [IPv6域名列表, 可配多个域名]"
+    )
+    ddns.add_argument("--ttl", type=int, help="DNS TTL(s) [设置域名解析过期时间]")
+    ddns.add_argument("--line", help="DNS line/route [DNS线路设置]")
+
+    # Advanced Options group
+    advanced = arg.add_argument_group("Advanced Options [高级参数]")
+    advanced.add_argument("--proxy", nargs="*", action=ExtendAction, help="HTTP proxy [设置http代理，可配多个代理连接]")
+    advanced.add_argument(
+        "--cache", type=str_bool, nargs="?", const=True, help="set cache [启用缓存开关，或传入保存路径]"
+    )
+    advanced.add_argument(
+        "--no-cache", dest="cache", action="store_const", const=False, help="disable cache [关闭缓存等效 --cache=false]"
+    )
+    advanced.add_argument(
+        "--ssl",
+        type=str_bool,
+        nargs="?",
+        const=True,
+        help="SSL certificate verification [SSL证书验证方式]: "
+        "true(强制验证), false(禁用验证), auto(自动降级), /path/to/cert.pem(自定义证书)",
+    )
+    advanced.add_argument(
+        "--no-ssl",
+        dest="ssl",
+        action="store_const",
+        const=False,
+        help="disable SSL verify [禁用验证, 等效 --ssl=false]",
+    )
+    advanced.add_argument("--log_file", metavar="FILE", help="log file [日志文件，默认标准输出]")
+    advanced.add_argument("--log.file", "--log-file", dest="log_file", help=SUPPRESS)  # 隐藏参数
+    advanced.add_argument("--log_level", type=log_level, metavar="|".join(log_levels), help=None)
+    advanced.add_argument("--log.level", "--log-level", dest="log_level", type=log_level, help=SUPPRESS)  # 隐藏参数
+    advanced.add_argument("--log_format", metavar="FORMAT", help="set log format [日志格式]")
+    advanced.add_argument("--log.format", "--log-format", dest="log_format", help=SUPPRESS)  # 隐藏参数
+    advanced.add_argument("--log_datefmt", metavar="FORMAT", help="set log date format [日志时间格式]")
+    advanced.add_argument("--log.datefmt", "--log-datefmt", dest="log_datefmt", help=SUPPRESS)  # 隐藏参数
+
+
+def _add_task_subcommand_if_needed(parser):  # type: (ArgumentParser) -> None
+    """
+    Conditionally add task subcommand to avoid Python 2 'too few arguments' error.
+
+    Python 2's argparse requires subcommand when subparsers are defined, but Python 3 doesn't.
+    We only add subparsers when the first argument is likely a subcommand (doesn't start with '-').
+    """
+    # Python2 Only add subparsers when first argument is a subcommand (not an option)
+    if len(sys.argv) <= 1 or (sys.argv[1].startswith("-") and sys.argv[1] != "--help"):
+        return
+
+    # Add subparsers for subcommands
+    subparsers = parser.add_subparsers(dest="command", help="subcommands [子命令]")
+
+    # Create task subcommand parser
+    task = subparsers.add_parser("task", help="Manage scheduled tasks [管理定时任务]")
+    task.set_defaults(func=_handle_task_command)
+    _add_ddns_args(task)
+
+    # Add task-specific arguments
+    task.add_argument(
+        "-i",
+        "--install",
+        nargs="?",
+        type=int,
+        const=5,
+        metavar="MINs",
+        help="Install task with <mins> [安装定时任务，默认5分钟]",
+    )
+    task.add_argument("--uninstall", action="store_true", help="Uninstall scheduled task [卸载定时任务]")
+    task.add_argument("--status", action="store_true", help="Show task status [显示定时任务状态]")
+    task.add_argument("--enable", action="store_true", help="Enable scheduled task [启用定时任务]")
+    task.add_argument("--disable", action="store_true", help="Disable scheduled task [禁用定时任务]")
+    task.add_argument(
+        "--scheduler",
+        choices=["auto", "systemd", "cron", "launchd", "schtasks"],
+        default="auto",
+        help="Specify scheduler type [指定定时任务方式]",
+    )
+
+
+def load_config(description, doc, version, date):
+    # type: (str, str, str, str) -> dict
+    """
+    解析命令行参数并返回配置字典。
+
+    Args:
+        description (str): 程序描述
+        doc (str): 程序文档
+        version (str): 程序版本
+        date (str): 构建日期
+
+    Returns:
+        dict: 配置字典
+    """
+    parser = ArgumentParser(description=description, epilog=doc, formatter_class=RawTextHelpFormatter)
+    sysinfo = _get_system_info_str()
+    pyinfo = _get_python_info_str()
+    compiled = getattr(sys.modules["__main__"], "__compiled__", "")
+    version_str = "v{} ({})\n{}\n{}\n{}".format(version, date, pyinfo, sysinfo, compiled)
+
+    _add_ddns_args(parser)  # Add common DDNS arguments to main parser
+    # Default behavior (no subcommand) - add all the regular DDNS options
+    parser.add_argument("-v", "--version", action="version", version=version_str)
+    parser.add_argument(
+        "--new-config", metavar="FILE", action=NewConfigAction, nargs="?", help="generate new config [生成配置文件]"
+    )
+
+    # Python 2/3 compatibility: conditionally add subparsers to avoid 'too few arguments' error
+    # Subparsers are only needed when user provides a subcommand (non-option argument)
+    _add_task_subcommand_if_needed(parser)
+
+    args, unknown = parser.parse_known_args()
+
+    # Parse unknown arguments that follow --extra.xxx format
+    extra_args = {}  # type: dict
+    i = 0
+    while i < len(unknown):
+        arg = unknown[i]
+        if arg.startswith("--extra."):
+            key = "extra_" + arg[8:]  # Remove "--extra." and add "extra_" prefix
+            # Check if there's a value for this argument
+            if i + 1 < len(unknown) and not unknown[i + 1].startswith("--"):
+                extra_args[key] = unknown[i + 1]
+                i += 2
+            else:
+                # No value provided, set to True (flag)
+                extra_args[key] = True  # type: ignore[assignment]
+                i += 1
+        else:
+            # Unknown argument that doesn't match our pattern
+            sys.stderr.write("Warning: Unknown argument: {}\n".format(arg))
+            i += 1
+
+    # Merge extra_args into args namespace
+    for k, v in extra_args.items():
+        setattr(args, k, v)
+
+    # Handle task subcommand and exit early if present
+    if hasattr(args, "func"):
+        args.func(vars(args))
+        sys.exit(0)
+
+    is_debug = getattr(args, "debug", False)
+    if is_debug:
+        # 如果启用调试模式，则强制设置日志级别为 DEBUG
+        args.log_level = log_level("DEBUG")
+        if args.cache is None:
+            args.cache = False  # 禁用缓存
+
+    # 将 Namespace 对象转换为字典并直接返回
+    config = vars(args)
+    return {k: v for k, v in config.items() if v is not None}  # 过滤掉 None 值的配置项
+
+
+def _handle_task_command(args):  # type: (dict) -> None
+    """Handle task subcommand"""
+    basicConfig(level=args["debug"] and DEBUG or args.get("log_level", "INFO"))
+
+    # Use specified scheduler or auto-detect
+    scheduler_type = args.get("scheduler", "auto")
+    scheduler = get_scheduler(scheduler_type)
+
+    interval = args.get("install", 5) or 5
+    excluded_keys = ("status", "install", "uninstall", "enable", "disable", "command", "scheduler", "func")
+    ddns_args = {k: v for k, v in args.items() if k not in excluded_keys and v is not None}
+
+    # Execute operations
+    for op in ["install", "uninstall", "enable", "disable"]:
+        if not args.get(op):
+            continue
+
+        # Check if task is installed for enable/disable
+        if op in ["enable", "disable"] and not scheduler.is_installed():
+            print("DDNS task is not installed" + (" Please install it first." if op == "enable" else "."))
+            sys.exit(1)
+
+        # Execute operation
+        print("{} DDNS scheduled task...".format(op.title()))
+        func = getattr(scheduler, op)
+        result = func(interval, ddns_args) if op == "install" else func()
+
+        if result:
+            past_tense = {
+                "install": "installed",
+                "uninstall": "uninstalled",
+                "enable": "enabled",
+                "disable": "disabled",
+            }[op]
+            suffix = " with {} minute interval".format(interval) if op == "install" else ""
+            print("DDNS task {} successfully{}".format(past_tense, suffix))
+        else:
+            print("Failed to {} DDNS task".format(op))
+            sys.exit(1)
+        return
+
+    # Show status or auto-install
+    status = scheduler.get_status()
+
+    if args.get("status") or status["installed"]:
+        print("DDNS Task Status:")
+        print("  Installed: {}".format("Yes" if status["installed"] else "No"))
+        print("  Scheduler: {}".format(status["scheduler"]))
+        if status["installed"]:
+            print("  Enabled: {}".format(status.get("enabled", "unknown")))
+            print("  Interval: {} minutes".format(status.get("interval", "unknown")))
+            print("  Command: {}".format(status.get("command", "unknown")))
+            print("  Description: {}".format(status.get("description", "")))
+    else:
+        print("DDNS task is not installed. Installing with default settings...")
+        if scheduler.install(interval, ddns_args):
+            print("DDNS task installed successfully with {} minute interval".format(interval))
+        else:
+            print("Failed to install DDNS task")
+            sys.exit(1)