ddns 4.1.0b1__py2.py3-none-any.whl → 4.1.0b3__py2.py3-none-any.whl

ddns/__builtins__.pyi

@@ -1,5 +1,6 @@
 # coding=utf-8
 # flake8: noqa: F401
+# ruff: noqa: F403
 from typing import *
 from .provider import SimpleProvider
 import logging

ddns/__init__.py

@@ -6,16 +6,7 @@ ddns Package
 __description__ = "automatically update DNS records to my IP [域名自动指向本机IP]"
 
 # 编译时，版本会被替换
-__version__ = "4.1.0b1"
+__version__ = "4.1.0b3"
 
 # 时间也会被替换掉
-build_date = "2025-07-03T13:20:03Z"
-
-__doc__ = """
-ddns [v{}@{}]
-(i) homepage or docs [文档主页]: https://ddns.newfuture.cc/
-(?) issues or bugs [问题和反馈]: https://github.com/NewFuture/DDNS/issues
-Copyright (c) NewFuture (MIT License)
-""".format(
-    __version__, build_date
-)
+build_date = "2025-08-11T15:00:49Z"

ddns/__main__.py

@@ -4,189 +4,142 @@ DDNS
 @author: NewFuture, rufengsuixing
 """
 
-from os import path, environ, name as os_name
 from io import TextIOWrapper
 from subprocess import check_output
-from tempfile import gettempdir
-from logging import basicConfig, getLogger, info, error, debug, warning, INFO
-
+from logging import getLogger
 import sys
 
-from .__init__ import __version__, __description__, __doc__, build_date
-from .util import ip
-from .util.cache import Cache
-from .util.config import init_config, get_config
+from .__init__ import __version__, __description__, build_date
+from .config import load_configs, Config  # noqa: F401
 from .provider import get_provider_class, SimpleProvider  # noqa: F401
+from . import ip
+from .cache import Cache
 
-environ["DDNS_VERSION"] = __version__
-
-
-def is_false(value):
-    """
-    判断值是否为 False
-    字符串 'false', 或者 False, 或者 'none';
-    0 不是 False
-    """
-    if hasattr(value, "strip"):  # 字符串
-        return value.strip().lower() in ["false", "none"]
-    return value is False
+logger = getLogger()
 
 
-def get_ip(ip_type, index="default"):
+def get_ip(ip_type, rules):
     """
     get IP address
     """
-    # CN: 捕获异常
-    # EN: Catch exceptions
-    value = None
-    try:
-        debug("get_ip(%s, %s)", ip_type, index)
-        if is_false(index):  # disabled
-            return False
-        elif isinstance(index, list):  # 如果获取到的规则是列表，则依次判断列表中每一个规则，直到获取到IP
-            for i in index:
-                value = get_ip(ip_type, i)
-                if value:
-                    break
-        elif str(index).isdigit():  # 数字 local eth
-            value = getattr(ip, "local_v" + ip_type)(index)
-        elif index.startswith("cmd:"):  # cmd
-            value = str(check_output(index[4:]).strip().decode("utf-8"))
-        elif index.startswith("shell:"):  # shell
-            value = str(check_output(index[6:], shell=True).strip().decode("utf-8"))
-        elif index.startswith("url:"):  # 自定义 url
-            value = getattr(ip, "public_v" + ip_type)(index[4:])
-        elif index.startswith("regex:"):  # 正则 regex
-            value = getattr(ip, "regex_v" + ip_type)(index[6:])
-        else:
-            value = getattr(ip, index + "_v" + ip_type)()
-    except Exception as e:
-        error("Failed to get %s address: %s", ip_type, e)
-    return value
-
-
-def change_dns_record(dns, proxy_list, **kw):
-    # type: (SimpleProvider, list, **(str)) -> bool
-    for proxy in proxy_list:
-        if not proxy or (proxy.upper() in ["DIRECT", "NONE"]):
-            dns.set_proxy(None)
-        else:
-            dns.set_proxy(proxy)
-        record_type, domain = kw["record_type"], kw["domain"]
+    if rules is False:  # disabled
+        return False
+    for i in rules:
         try:
-            return dns.set_record(domain, kw["ip"], record_type=record_type, ttl=kw["ttl"], line=kw.get("line"))
+            logger.debug("get_ip:(%s, %s)", ip_type, i)
+            if str(i).isdigit():  # 数字 local eth
+                return getattr(ip, "local_v" + ip_type)(i)
+            elif i.startswith("cmd:"):  # cmd
+                return str(check_output(i[4:]).strip().decode("utf-8"))
+            elif i.startswith("shell:"):  # shell
+                return str(check_output(i[6:], shell=True).strip().decode("utf-8"))
+            elif i.startswith("url:"):  # 自定义 url
+                return getattr(ip, "public_v" + ip_type)(i[4:])
+            elif i.startswith("regex:"):  # 正则 regex
+                return getattr(ip, "regex_v" + ip_type)(i[6:])
+            else:
+                return getattr(ip, i + "_v" + ip_type)()
         except Exception as e:
-            error("Failed to update %s record for %s: %s", record_type, domain, e)
-    return False
+            logger.error("Failed to get %s address: %s", ip_type, e)
+    return None
 
 
-def update_ip(ip_type, cache, dns, ttl, line, proxy_list):
-    # type: (str, Cache | None, SimpleProvider, str, str | None, list[str]) -> bool | None
+def update_ip(dns, cache, index_rule, domains, record_type, config):
+    # type: (SimpleProvider, Cache | None, list[str]|bool, list[str], str, Config) -> bool | None
     """
-    更新IP
+    更新IP并变更DNS记录
     """
-    ipname = "ipv" + ip_type
-    domains = get_config(ipname)
     if not domains:
         return None
-    if not isinstance(domains, list):
-        domains = domains.strip("; ").replace(",", ";").replace(" ", ";").split(";")
 
-    index_rule = get_config("index" + ip_type, "default")  # type: str # type: ignore
+    ip_type = "4" if record_type == "A" else "6"
     address = get_ip(ip_type, index_rule)
     if not address:
-        error("Fail to get %s address!", ipname)
+        logger.error("Fail to get %s address!", ip_type)
         return False
 
-    record_type = "A" if ip_type == "4" else "AAAA"
     update_success = False
 
-    # Check cache and update each domain individually
     for domain in domains:
         domain = domain.lower()
         cache_key = "{}:{}".format(domain, record_type)
         if cache and cache.get(cache_key) == address:
-            info("%s[%s] address not changed, using cache: %s", domain, record_type, address)
-            update_success = True  # At least one domain is successfully cached
+            logger.info("%s[%s] address not changed, using cache: %s", domain, record_type, address)
+            update_success = True
         else:
-            # Update domain that is not cached or has different IP
-            if change_dns_record(dns, proxy_list, domain=domain, ip=address, record_type=record_type, ttl=ttl, line=line):
-                warning("set %s[IPv%s]: %s successfully.", domain, ip_type, address)
-                update_success = True
-                # Cache successful update immediately
-                if isinstance(cache, dict):
-                    cache[cache_key] = address
-
+            try:
+                result = dns.set_record(domain, address, record_type=record_type, ttl=config.ttl, line=config.line)
+                if result:
+                    logger.warning("set %s[IPv%s]: %s successfully.", domain, ip_type, address)
+                    update_success = True
+                    if isinstance(cache, dict):
+                        cache[cache_key] = address
+                else:
+                    logger.error("Failed to update %s record for %s", record_type, domain)
+            except Exception as e:
+                logger.exception("Failed to update %s record for %s: %s", record_type, domain, e)
     return update_success
 
 
-def main():
+def run(config):
+    # type: (Config) -> bool
     """
-    更新
+    Run the DDNS update process
     """
+    # 设置IP模块的SSL验证配置
+    ip.ssl_verify = config.ssl
+
+    # 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
+    )
+    cache = Cache.new(config.cache, config.md5(), logger)
+    return (
+        update_ip(dns, cache, config.index4, config.ipv4, "A", config) is not False
+        and update_ip(dns, cache, config.index6, config.ipv6, "AAAA", config) is not False
+    )
+
+
+def main():
     encode = sys.stdout.encoding
     if encode is not None and encode.lower() != "utf-8" and hasattr(sys.stdout, "buffer"):
         # 兼容windows 和部分ASCII编码的老旧系统
         sys.stdout = TextIOWrapper(sys.stdout.buffer, encoding="utf-8")
         sys.stderr = TextIOWrapper(sys.stderr.buffer, encoding="utf-8")
-    init_config(__description__, __doc__, __version__, build_date)
-
-    log_level = get_config("log.level", INFO)  # type: int # type: ignore
-    log_format = get_config("log.format")  # type: str | None # type: ignore
-    if log_format:
-        # A custom log format is already set; no further action is required.
-        pass
-    elif log_level < 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 log_level > INFO:
-        log_format = "%(asctime)s %(levelname)s: %(message)s"
-    else:
-        log_format = "%(asctime)s %(levelname)s [%(name)s]: %(message)s"
-    basicConfig(
-        level=log_level,
-        format=log_format,
-        datefmt=get_config("log.datefmt", "%Y-%m-%dT%H:%M:%S"),  # type: ignore
-        filename=get_config("log.file"),  # type: ignore
-    )
-    logger = getLogger()
     logger.name = "ddns"
 
-    debug("DDNS[ %s ] run: %s %s", __version__, os_name, sys.platform)
+    # 使用多配置加载器，它会自动处理单个和多个配置
+    configs = load_configs(__description__, __version__, build_date)
 
-    # dns provider class
-    dns_name = get_config("dns", "debug")  # type: str # type: ignore
-    provider_class = get_provider_class(dns_name)
-    ssl_config = get_config("ssl", "auto")  # type: str | bool # type: ignore
-    dns = provider_class(get_config("id"), get_config("token"), logger=logger, verify_ssl=ssl_config)  # type: ignore
-
-    if get_config("config"):
-        info("loaded Config from: %s", path.abspath(get_config("config")))  # type: ignore
-
-    proxy = get_config("proxy") or "DIRECT"
-    proxy_list = proxy if isinstance(proxy, list) else proxy.strip(";").replace(",", ";").split(";")
-
-    cache_config = get_config("cache", True)  # type: bool | str  # type: ignore
-    if cache_config is False:
-        cache = None
-    elif cache_config is True:
-        cache = Cache(path.join(gettempdir(), "ddns.cache"), logger)
-    else:
-        cache = Cache(cache_config, logger)
-
-    if cache is None:
-        info("Cache is disabled!")
-    elif get_config("config_modified_time", float("inf")) >= cache.time:  # type: ignore
-        info("Cache file is outdated.")
-        cache.clear()
-    elif len(cache) == 0:
-        debug("Cache is empty.")
+    if len(configs) == 1:
+        # 单个配置，使用原有逻辑（向后兼容）
+        config = configs[0]
+        success = run(config)
+        if not success:
+            sys.exit(1)
     else:
-        debug("Cache loaded with %d entries.", len(cache))
-    ttl = get_config("ttl")  # type: str # type: ignore
-    line = get_config("line")  # type: str | None # type: ignore
-    update_ip("4", cache, dns, ttl, line, proxy_list)
-    update_ip("6", cache, dns, ttl, line, proxy_list)
+        # 多个配置，使用新的批处理逻辑
+        overall_success = True
+        for i, config in enumerate(configs):
+            # 如果log_level有值则设置setLevel
+            if hasattr(config, "log_level") and config.log_level:
+                logger.setLevel(config.log_level)
+            logger.info("Running configuration %d/%d", i + 1, len(configs))
+            # 记录当前provider
+            logger.info("Using DNS provider: %s", config.dns)
+            success = run(config)
+            if not success:
+                overall_success = False
+                logger.error("Configuration %d failed", i + 1)
+            else:
+                logger.info("Configuration %d completed successfully", i + 1)
+
+        if not overall_success:
+            logger.error("Some configurations failed")
+            sys.exit(1)
+        else:
+            logger.info("All configurations completed successfully")
 
 
 if __name__ == "__main__":

ddns/{util/cache.py → cache.py}

@@ -4,10 +4,11 @@ cache module
 文件缓存
 """
 
+from logging import getLogger, Logger  # noqa: F401
 from os import path, stat
-from pickle import dump, load
+from json import load, dump
+from tempfile import gettempdir
 from time import time
-from logging import getLogger, Logger  # noqa: F401
 
 
 class Cache(dict):
@@ -40,18 +41,20 @@ class Cache(dict):
             file = self.__filename
 
         self.__logger.debug("load cache data from %s", file)
-        if file and path.isfile(file):
-            with open(file, "rb") as data:
-                try:
+        if file:
+            try:
+                with open(file, "r") as data:
                     loaded_data = load(data)
                     self.clear()
                     self.update(loaded_data)
                     self.__time = stat(file).st_mtime
                     return self
-                except ValueError:
-                    pass
-                except Exception as e:
-                    self.__logger.warning(e)
+            except (IOError, OSError):
+                self.__logger.info("cache file not exist or cannot be opened")
+            except ValueError:
+                pass
+            except Exception as e:
+                self.__logger.warning(e)
         else:
             self.__logger.info("cache file not exist")
 
@@ -63,10 +66,10 @@ class Cache(dict):
     def sync(self):
         """Sync the write buffer with the cache files and clear the buffer."""
         if self.__changed and self.__filename:
-            with open(self.__filename, "wb") as data:
+            with open(self.__filename, "w") as data:
                 # 只保存非私有字段（不以__开头的字段）
                 filtered_data = {k: v for k, v in super(Cache, self).items() if not k.startswith("__")}
-                dump(filtered_data, data)
+                dump(filtered_data, data, separators=(",", ":"))
                 self.__logger.debug("save cache data to %s", self.__filename)
             self.__time = time()
             self.__changed = False
@@ -150,3 +153,31 @@ class Cache(dict):
 
     def __del__(self):
         self.close()
+
+    @staticmethod
+    def new(config_cache, hash, logger):
+        # type: (str|bool, str, Logger) -> Cache|None
+        """
+        new cache from a file path.
+        :param path: Path to the cache file.
+        :param logger: Optional logger for debug messages.
+        :return: Cache instance with loaded data.
+        """
+        if config_cache is False:
+            cache = None
+        elif config_cache is True:
+            cache_path = path.join(gettempdir(), "ddns.%s.cache" % hash)
+            cache = Cache(cache_path, logger)
+        else:
+            cache = Cache(config_cache, logger)
+
+        if cache is None:
+            logger.debug("Cache is disabled!")
+        elif cache.time + 72 * 3600 < time():  # 72小时有效期
+            logger.info("Cache file is outdated.")
+            cache.clear()
+        elif len(cache) == 0:
+            logger.debug("Cache is empty.")
+        else:
+            logger.debug("Cache loaded with %d entries.", len(cache))
+        return cache

ddns/{util/ip.py → ip.py}

@@ -5,10 +5,10 @@ from os import name as os_name, popen
 from socket import socket, getaddrinfo, gethostname, AF_INET, AF_INET6, SOCK_DGRAM
 from logging import debug, error
 
-try:  # python3
-    from urllib.request import urlopen, Request
-except ImportError:  # python2
-    from urllib2 import urlopen, Request  # type: ignore[import-untyped]  # noqa: F401
+from .util.http import request
+
+# 模块级别的SSL验证配置，默认使用auto模式
+ssl_verify = "auto"
 
 # IPV4正则
 IPV4_REG = r"((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])"
@@ -48,13 +48,14 @@ def local_v4(i=0):  # 本地ipv4地址
 def _open(url, reg):
     try:
         debug("open: %s", url)
-        res = (
-            urlopen(Request(url, headers={"User-Agent": "Mozilla/5.0 ddns"}), timeout=60)
-            .read()
-            .decode("utf8", "ignore")
-        )
+        # IP 模块重试3次
+        response = request("GET", url, verify=ssl_verify, retries=2)
+        res = response.body
         debug("response: %s", res)
-        return compile(reg).search(res).group()
+        match = compile(reg).search(res)
+        if match:
+            return match.group()
+        error("No match found in response: %s", res)
     except Exception as e:
         error(e)
 
@@ -68,7 +69,6 @@ def public_v6(url="https://api-ipv6.ip.sb/ip", reg=IPV6_REG):  # 公网IPV6地
 
 
 def _ip_regex_match(parrent_regex, match_regex):
-
     ip_pattern = compile(parrent_regex)
     matcher = compile(match_regex)
 

ddns/provider/__init__.py

@@ -1,15 +1,21 @@
 # coding=utf-8
-from ._base import SimpleProvider  # noqa: F401
+from ._base import SimpleProvider
 from .alidns import AlidnsProvider
+from .aliesa import AliesaProvider
 from .callback import CallbackProvider
 from .cloudflare import CloudflareProvider
+from .debug import DebugProvider
 from .dnscom import DnscomProvider
 from .dnspod import DnspodProvider
 from .dnspod_com import DnspodComProvider
+from .edgeone import EdgeOneProvider
 from .he import HeProvider
 from .huaweidns import HuaweiDNSProvider
+from .namesilo import NamesiloProvider
+from .noip import NoipProvider
 from .tencentcloud import TencentCloudProvider
-from .debug import DebugProvider
+
+__all__ = ["SimpleProvider", "get_provider_class"]
 
 
 def get_provider_class(provider_name):
@@ -32,15 +38,22 @@ def get_provider_class(provider_name):
         "tencentcloud": TencentCloudProvider,
         "tencent": TencentCloudProvider,  # 兼容tencent
         "qcloud": TencentCloudProvider,  # 兼容qcloud
+        # tencent cloud edgeone
+        "edgeone": EdgeOneProvider,
+        "teo": EdgeOneProvider,  # 兼容teo (EdgeOne产品的API名称)
+        "tencentedgeone": EdgeOneProvider,  # 兼容tencentedgeone
         # cloudflare
         "cloudflare": CloudflareProvider,
         # aliyun alidns
         "alidns": AlidnsProvider,
         "aliyun": AlidnsProvider,  # 兼容aliyun
+        # aliyun esa
+        "aliesa": AliesaProvider,
+        "esa": AliesaProvider,  # 兼容esa
         # dns.com
         "dnscom": DnscomProvider,
-        "51dns": DnscomProvider,  # 兼容旧的51dns
-        "dns_com": DnscomProvider,  # 兼容旧的dns_com
+        "51dns": DnscomProvider,  # 兼容51dns
+        "dns_com": DnscomProvider,  # 兼容dns_com
         # he.net
         "he": HeProvider,
         "he_net": HeProvider,  # 兼容he.net
@@ -48,6 +61,13 @@ def get_provider_class(provider_name):
         "huaweidns": HuaweiDNSProvider,
         "huawei": HuaweiDNSProvider,  # 兼容huawei
         "huaweicloud": HuaweiDNSProvider,
+        # namesilo
+        "namesilo": NamesiloProvider,
+        "namesilo_com": NamesiloProvider,  # 兼容namesilo.com
+        # no-ip
+        "noip": NoipProvider,
+        "no-ip": NoipProvider,  # 兼容no-ip
+        "noip_com": NoipProvider,  # 兼容noip.com
         # callback
         "callback": CallbackProvider,
         "webhook": CallbackProvider,  # 兼容