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

ddns/provider/noip.py

@@ -0,0 +1,103 @@
+# coding=utf-8
+"""
+No-IP (noip.com) Dynamic DNS API
+@author: GitHub Copilot
+"""
+
+import base64
+from ._base import SimpleProvider, TYPE_FORM
+
+
+class NoipProvider(SimpleProvider):
+    """
+    No-IP (www.noip.com) Dynamic DNS Provider
+
+    No-IP is a popular dynamic DNS service that provides simple HTTP-based
+    API for updating DNS records. This provider supports the standard
+    No-IP update protocol.
+    """
+
+    endpoint = "https://dynupdate.no-ip.com"
+    content_type = TYPE_FORM
+    accept = None  # No-IP returns plain text response
+    decode_response = False  # Response is plain text, not JSON
+
+    def _validate(self):
+        """
+        Validate authentication credentials for No-IP
+        """
+        if not self.id:
+            raise ValueError("No-IP requires username as 'id'")
+        if not self.token:
+            raise ValueError("No-IP requires password as 'token'")
+
+    def set_record(self, domain, value, record_type="A", ttl=None, line=None, **extra):
+        """
+        Update DNS record using No-IP Dynamic Update API
+
+        No-IP API Reference:
+        - URL: https://dynupdate.no-ip.com/nic/update
+        - Method: GET or POST
+        - Authentication: HTTP Basic Auth (username:password)
+        - Parameters:
+          - hostname: The hostname to update
+          - myip: The IP address to set (optional, uses client IP
+                  if not provided)
+
+        Response codes:
+        - good: Update successful
+        - nochg: IP address is current, no update performed
+        - nohost: Hostname supplied does not exist
+        - badauth: Invalid username/password combination
+        - badagent: Client disabled
+        - !donator: An update request was sent including a feature that
+                    is not available
+        - abuse: Username is blocked due to abuse
+        """
+        self.logger.info("%s => %s(%s)", domain, value, record_type)
+
+        # Prepare request parameters
+        params = {"hostname": domain, "myip": value}
+
+        # Prepare HTTP Basic Authentication headers
+        auth_string = "{0}:{1}".format(self.id, self.token)
+        if not isinstance(auth_string, bytes):  # Python 3
+            auth_bytes = auth_string.encode("utf-8")
+        else:  # Python 2
+            auth_bytes = auth_string
+
+        auth_b64 = base64.b64encode(auth_bytes).decode("ascii")
+        headers = {
+            "Authorization": "Basic {0}".format(auth_b64),
+        }
+
+        try:
+            # Use GET request as it's the most common method for DDNS
+            response = self._http("GET", "/nic/update", queries=params, headers=headers)
+
+            if response is not None:
+                response_str = str(response).strip()
+                self.logger.info("No-IP API response: %s", response_str)
+
+                # Check for successful responses
+                if response_str.startswith("good") or response_str.startswith("nochg"):
+                    return True
+                elif response_str.startswith("nohost"):
+                    self.logger.error("Hostname %s does not exist under No-IP account", domain)
+                elif response_str.startswith("badauth"):
+                    self.logger.error("Invalid No-IP username/password combination")
+                elif response_str.startswith("badagent"):
+                    self.logger.error("No-IP client disabled")
+                elif response_str.startswith("!donator"):
+                    self.logger.error("Feature not available for No-IP free account")
+                elif response_str.startswith("abuse"):
+                    self.logger.error("No-IP account blocked due to abuse")
+                else:
+                    self.logger.error("Unexpected No-IP API response: %s", response_str)
+            else:
+                self.logger.error("Empty response from No-IP API")
+
+        except Exception as e:
+            self.logger.error("Error updating No-IP record for %s: %s", domain, e)
+
+        return False

ddns/provider/tencentcloud.py

@@ -5,9 +5,9 @@ Tencent Cloud DNSPod API
 
 @author: NewFuture
 """
-from ._base import BaseProvider, TYPE_JSON, hmac_sha256_authorization, sha256_hash, hmac_sha256
+from ._base import BaseProvider, TYPE_JSON
+from ._signature import hmac_sha256_authorization, sha256_hash, hmac_sha256
 from time import time, strftime, gmtime
-from json import dumps as jsonencode
 
 
 class TencentCloudProvider(BaseProvider):
@@ -19,7 +19,7 @@ class TencentCloudProvider(BaseProvider):
     Documentation: https://cloud.tencent.com/document/api/1427
     """
 
-    API = "https://dnspod.tencentcloudapi.com"
+    endpoint = "https://dnspod.tencentcloudapi.com"
     content_type = TYPE_JSON
 
     # 腾讯云 DNSPod API 配置
@@ -42,12 +42,12 @@ class TencentCloudProvider(BaseProvider):
         """
         # 构建请求体
         params = {k: v for k, v in params.items() if v is not None}
-        body = jsonencode(params)
+        body = self._encode_body(params)
 
         # 构建请求头,小写 腾讯云只签名特定头部
         headers = {
             "content-type": self.content_type,
-            "host": self.API.split("://", 1)[1].strip("/"),
+            "host": self.endpoint.split("://", 1)[1].strip("/"),
         }
 
         # 腾讯云特殊的密钥派生过程
@@ -55,13 +55,13 @@ class TencentCloudProvider(BaseProvider):
         credential_scope = "{}/{}/tc3_request".format(date, self.service)
 
         # 派生签名密钥
-        secret_date = hmac_sha256("TC3" + self.auth_token, date).digest()
+        secret_date = hmac_sha256("TC3" + self.token, date).digest()
         secret_service = hmac_sha256(secret_date, self.service).digest()
         signing_key = hmac_sha256(secret_service, "tc3_request").digest()
 
         # 预处理模板字符串
         auth_format = "TC3-HMAC-SHA256 Credential=%s/%s, SignedHeaders={SignedHeaders}, Signature={Signature}" % (
-            self.auth_id,
+            self.id,
             credential_scope,
         )
         timestamp = str(int(time()))

ddns/util/comment.py

@@ -0,0 +1,88 @@
+# -*- coding:utf-8 -*-
+"""
+Comment removal utility for JSON configuration files.
+Supports both # and // style single line comments.
+@author: GitHub Copilot
+"""
+
+
+def remove_comment(content):
+    # type: (str) -> str
+    """
+    移除字符串中的单行注释。
+    支持 # 和 // 两种注释风格。
+
+    Args:
+        content (str): 包含注释的字符串内容
+
+    Returns:
+        str: 移除注释后的字符串
+
+    Examples:
+        >>> remove_comment('{"key": "value"} // comment')
+        '{"key": "value"} '
+        >>> remove_comment('# This is a comment\\n{"key": "value"}')
+        '\\n{"key": "value"}'
+    """
+    if not content:
+        return content
+
+    lines = content.splitlines()
+    cleaned_lines = []
+
+    for line in lines:
+        # 移除行内注释，但要小心不要破坏字符串内的内容
+        cleaned_line = _remove_line_comment(line)
+        cleaned_lines.append(cleaned_line)
+
+    return "\n".join(cleaned_lines)
+
+
+def _remove_line_comment(line):
+    # type: (str) -> str
+    """
+    移除单行中的注释部分。
+
+    Args:
+        line (str): 要处理的行
+
+    Returns:
+        str: 移除注释后的行
+    """
+    # 检查是否是整行注释
+    stripped = line.lstrip()
+    if stripped.startswith("#") or stripped.startswith("//"):
+        return ""
+
+    # 查找行内注释，需要考虑字符串内容
+    in_string = False
+    quote_char = None
+    i = 0
+
+    while i < len(line):
+        char = line[i]
+
+        # 处理字符串内的转义序列
+        if in_string and char == "\\" and i + 1 < len(line):
+            i += 2  # 跳过转义字符
+            continue
+
+        # 处理引号字符
+        if char in ('"', "'"):
+            if not in_string:
+                in_string = True
+                quote_char = char
+            elif char == quote_char:
+                in_string = False
+                quote_char = None
+
+        # 在字符串外检查注释标记
+        elif not in_string:
+            if char == "#":
+                return line[:i].rstrip()
+            elif char == "/" and i + 1 < len(line) and line[i + 1] == "/":
+                return line[:i].rstrip()
+
+        i += 1
+
+    return line

ddns/util/http.py

@@ -13,13 +13,20 @@ import ssl
 import os
 
 try:  # python 3
-    from http.client import HTTPSConnection, HTTPConnection, HTTPException
-    from urllib.parse import urlparse
+    from urllib.request import Request, HTTPSHandler, ProxyHandler, build_opener, OpenerDirector  # noqa: F401
+    from urllib.parse import quote, urlencode
+    from urllib.error import HTTPError, URLError
 except ImportError:  # python 2
-    from httplib import HTTPSConnection, HTTPConnection, HTTPException  # type: ignore[no-redef]
-    from urlparse import urlparse  # type: ignore[no-redef]
+    from urllib2 import Request, HTTPSHandler, ProxyHandler, build_opener, HTTPError, URLError  # type: ignore[no-redef]
+    from urllib import urlencode, quote  # type: ignore[no-redef]
 
-__all__ = ["send_http_request", "HttpResponse"]
+__all__ = [
+    "send_http_request",
+    "HttpResponse",
+    "quote",
+    "urlencode",
+    "URLError",
+]
 
 logger = getLogger().getChild(__name__)
 
@@ -28,14 +35,14 @@ class HttpResponse(object):
     """HTTP响应封装类"""
 
     def __init__(self, status, reason, headers, body):
-        # type: (int, str, list[tuple[str, str]], str) -> None
+        # type: (int, str, object, str) -> None
         """
         初始化HTTP响应对象
 
         Args:
             status (int): HTTP状态码
             reason (str): 状态原因短语
-            headers (list[tuple[str, str]]): 响应头列表，保持原始格式和顺序
+            headers (object): 响应头对象，直接使用 response.info()
             body (str): 响应体内容
         """
         self.status = status
@@ -46,51 +53,42 @@ class HttpResponse(object):
     def get_header(self, name, default=None):
         # type: (str, str | None) -> str | None
         """
-        获取指定名称的头部值（不区分大小写）
+        获取指定名称的头部值
 
         Args:
             name (str): 头部名称
+            default (str | None): 默认值
 
         Returns:
-            str | None: 头部值，如果不存在则返回None
+            str | None: 头部值，如果不存在则返回默认值
         """
-        name_lower = name.lower()
-        for header_name, header_value in self.headers:
-            if header_name.lower() == name_lower:
-                return header_value
-        return default
+        return self.headers.get(name, default)  # type: ignore[union-attr]
 
 
-def _create_connection(hostname, port, is_https, proxy, verify_ssl):
-    # type: (str, int | None, bool, str | None, bool | str) -> HTTPConnection | HTTPSConnection
-    """创建HTTP/HTTPS连接"""
-    target = proxy or hostname
+# 移除了自定义重定向处理器，使用urllib2/urllib.request的内置重定向处理
 
-    if not is_https:
-        conn = HTTPConnection(target, port)
-    else:
-        ssl_context = ssl.create_default_context()
-
-        if verify_ssl is False:
-            # 禁用SSL验证
-            ssl_context.check_hostname = False
-            ssl_context.verify_mode = ssl.CERT_NONE
-        elif hasattr(verify_ssl, "lower") and verify_ssl.lower() not in ("auto", "true"):  # type: ignore[union-attr]
-            # 使用自定义CA证书 lower 判断 str/unicode 兼容 python2
-            try:
-                ssl_context.load_verify_locations(verify_ssl)  # type: ignore[arg-type]
-            except Exception as e:
-                logger.error("Failed to load CA certificate from %s: %s", verify_ssl, e)
-        else:
-            # 默认验证，尝试加载系统证书
-            _load_system_ca_certs(ssl_context)
-        conn = HTTPSConnection(target, port, context=ssl_context)
 
-    # 设置代理隧道
-    if proxy:
-        conn.set_tunnel(hostname, port)  # type: ignore[attr-defined]
+def _create_ssl_context(verify_ssl):
+    # type: (bool | str) -> ssl.SSLContext | None
+    """创建SSL上下文"""
+    ssl_context = ssl.create_default_context()
 
-    return conn
+    if verify_ssl is False:
+        # 禁用SSL验证
+        ssl_context.check_hostname = False
+        ssl_context.verify_mode = ssl.CERT_NONE
+    elif hasattr(verify_ssl, "lower") and verify_ssl.lower() not in ("auto", "true"):  # type: ignore[union-attr]
+        # 使用自定义CA证书
+        try:
+            ssl_context.load_verify_locations(verify_ssl)  # type: ignore[arg-type]
+        except Exception as e:
+            logger.error("Failed to load CA certificate from %s: %s", verify_ssl, e)
+            return None
+    else:
+        # 默认验证，尝试加载系统证书
+        _load_system_ca_certs(ssl_context)
+
+    return ssl_context
 
 
 def _load_system_ca_certs(ssl_context):
@@ -123,125 +121,78 @@ def _load_system_ca_certs(ssl_context):
                 loaded_count += 1
                 logger.debug("Loaded CA certificates from: %s", ca_path)
             except Exception as e:
-                logger.debug("Failed to load CA certificates from %s: %s", ca_path, e)
+                logger.info("Failed to load CA certificates from %s: %s", ca_path, e)
 
-    if loaded_count > 0:
-        logger.debug("Successfully loaded CA certificates from %d locations", loaded_count)
 
+def _create_opener(proxy, verify_ssl):
+    # type: (str | None, bool | str) -> OpenerDirector
+    """创建URL打开器，支持代理和SSL配置"""
+    handlers = []
 
-def _close_connection(conn):
-    # type: (HTTPConnection | HTTPSConnection) -> None
-    """关闭HTTP/HTTPS连接"""
-    try:
-        conn.close()
-    except Exception as e:
-        logger.warning("Failed to close connection: %s", e)
+    if proxy:
+        handlers.append(ProxyHandler({"http": proxy, "https": proxy}))
+
+    ssl_context = _create_ssl_context(verify_ssl)
+    if ssl_context:
+        handlers.append(HTTPSHandler(context=ssl_context))
+
+    return build_opener(*handlers)
 
 
-def send_http_request(method, url, body=None, headers=None, proxy=None, max_redirects=5, verify_ssl=True):
-    # type: (str, str, str | bytes | None, dict[str, str] | None, str | None, int, bool | str) -> HttpResponse
+def send_http_request(method, url, body=None, headers=None, proxy=None, verify_ssl=True):
+    # type: (str, str, str | bytes | None, dict[str, str] | None, str | None, bool | str) -> HttpResponse
     """
     发送HTTP/HTTPS请求，支持重定向跟随和灵活的SSL验证
-    Send HTTP/HTTPS request with support for redirect following and flexible SSL verification.
+
     Args:
         method (str): HTTP方法，如GET、POST等
         url (str): 请求的URL
         body (str | bytes | None): 请求体
         headers (dict[str, str] | None): 请求头
         proxy (str | None): 代理地址
-        max_redirects (int): 最大重定向次数
-        verify_ssl (bool | str): 是否验证SSL证书
+        verify_ssl (bool | str): SSL验证配置
+
     Returns:
-        HttpResponse: 响应对象，包含状态码、头部和解码后的内容
+        HttpResponse: 响应对象
+
     Raises:
-        HTTPException: 如果请求失败或重定向次数超过限制
+        URLError: 如果请求失败
         ssl.SSLError: 如果SSL验证失败
     """
-    if max_redirects <= 0:
-        raise HTTPException("Too many redirects")
+    # 准备请求
+    if isinstance(body, str):
+        body = body.encode("utf-8")
+
+    req = Request(url, data=body)
+    req.get_method = lambda: method  # type: ignore[attr-defined]
 
-    # 解析URL
-    url_obj = urlparse(url)
-    is_https = url_obj.scheme == "https"
-    hostname = url_obj.hostname or url_obj.netloc.split(":")[0]
-    request_path = "{}?{}".format(url_obj.path, url_obj.query) if url_obj.query else url_obj.path
-    headers = headers or {}
+    if headers:
+        for key, value in headers.items():
+            req.add_header(key, value)
 
-    # 创建连接
-    actual_verify_ssl = verify_ssl
-    conn = _create_connection(hostname, url_obj.port, is_https, proxy, verify_ssl)
+    # 创建opener并发送请求
+    opener = _create_opener(proxy, verify_ssl)
 
-    # 执行请求，处理SSL错误
     try:
-        conn.request(method, request_path, body, headers)
-        response = conn.getresponse()
+        response = opener.open(req)
+        response_headers = response.info()
+        raw_body = response.read()
+        decoded_body = _decode_response_body(raw_body, response_headers.get("Content-Type"))
+        return HttpResponse(response.getcode(), getattr(response, "msg", ""), response_headers, decoded_body)
+    except HTTPError as e:
+        # 记录HTTP错误并读取响应体用于调试
+        response_headers = getattr(e, "headers", {})
+        raw_body = e.read()
+        decoded_body = _decode_response_body(raw_body, response_headers.get("Content-Type"))
+        logger.error("HTTP error %s: %s for %s", e.code, getattr(e, "reason", str(e)), url)
+        return HttpResponse(e.code, getattr(e, "reason", str(e)), response_headers, decoded_body)
     except ssl.SSLError:
-        _close_connection(conn)
-        if verify_ssl == "auto" and is_https:
+        if verify_ssl == "auto":
             logger.warning("SSL verification failed, switching to unverified connection %s", url)
-            # 重新连接，忽略SSL验证
-            conn = _create_connection(hostname, url_obj.port, is_https, proxy, False)
-            conn.request(method, request_path, body, headers)
-            response = conn.getresponse()
-            actual_verify_ssl = False
+            return send_http_request(method, url, body, headers, proxy, False)
         else:
             raise
 
-    # 检查重定向
-    status = response.status
-    if 300 <= status < 400:
-        location = response.getheader("Location")
-        _close_connection(conn)
-        if not location:
-            # 无Location头的重定向
-            logger.warning("Redirect status %d but no Location header", status)
-            location = ""
-
-        # 构建重定向URL
-        redirect_url = _build_redirect_url(location, "{}://{}".format(url_obj.scheme, url_obj.netloc), url_obj.path)
-
-        # 如果重定向URL没有查询字符串，但原始URL有，则附加
-        if url_obj.query and "?" not in redirect_url:
-            redirect_url += "?" + url_obj.query
-
-        # 确定重定向方法：303或302+POST转为GET，其他保持原方法
-        if status == 303 or (status == 302 and method == "POST"):
-            method, body = "GET", None
-            # 如果从POST转为GET，移除相关的头部
-            if headers:
-                headers = {k: v for k, v in headers.items() if k.lower() not in ("content-length", "content-type")}
-
-        logger.info("Redirecting [%d] to: %s", status, redirect_url)
-        # 递归处理重定向
-        return send_http_request(method, redirect_url, body, headers, proxy, max_redirects - 1, actual_verify_ssl)
-
-    # 处理最终响应
-    content_type = response.getheader("Content-Type")
-    response_headers = response.getheaders()
-    raw_body = response.read()
-    _close_connection(conn)
-
-    # 解码响应体并创建响应对象
-    decoded_body = _decode_response_body(raw_body, content_type)
-    return HttpResponse(status, response.reason, response_headers, decoded_body)
-
-
-def _build_redirect_url(location, base, path):
-    # type: (str, str, str) -> str
-    """构建重定向URL，使用简单的字符串操作"""
-    if location.startswith("http"):
-        return location
-
-    if location.startswith("/"):
-        # 绝对路径：使用base的scheme和netloc
-        base_url = urlparse(base)
-        return "{}://{}{}".format(base_url.scheme, base_url.netloc, location)
-    else:
-        base_path = path.rsplit("/", 1)[0] if "/" in path else ""
-        if not base_path.endswith("/"):
-            base_path += "/"
-        return base + base_path + location
-
 
 def _decode_response_body(raw_body, content_type):
     # type: (bytes, str | None) -> str

{ddns-4.1.0b1.dist-info → ddns-4.1.0b2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ddns
-Version: 4.1.0b1
+Version: 4.1.0b2
 Summary: Dynamic DNS client for multiple providers, supporting IPv4 and IPv6.
 Author-email: NewFuture <python@newfuture.cc>
 License-Expression: MIT
@@ -84,12 +84,16 @@ Dynamic: license-file
 - 服务商支持:
   - [DNSPOD](https://www.dnspod.cn/) ([配置指南](doc/providers/dnspod.md))
   - [阿里 DNS](http://www.alidns.com/) ([配置指南](doc/providers/alidns.md)) ⚡
-  - [DNS.COM](https://www.dns.com/) (@loftor-git)
-  - [DNSPOD 国际版](https://www.dnspod.com/)
-  - [CloudFlare](https://www.cloudflare.com/) (@tongyifan)
-  - [HE.net](https://dns.he.net/) (@NN708) (不支持自动创建记录)
-  - [华为云](https://huaweicloud.com/) (@cybmp3) ⚡
+  - [阿里云边缘安全加速(ESA)](https://esa.console.aliyun.com/) ([配置指南](doc/providers/aliesa.md)) ⚡
+  - [DNS.COM](https://www.dns.com/) ([配置指南](doc/providers/51dns.md)) (@loftor-git)
+  - [DNSPOD 国际版](https://www.dnspod.com/) ([配置指南](doc/providers/dnspod_com.md))
+  - [CloudFlare](https://www.cloudflare.com/) ([配置指南](doc/providers/cloudflare.md)) (@tongyifan)
+  - [HE.net](https://dns.he.net/) ([配置指南](doc/providers/he.md)) (@NN708) (不支持自动创建记录)
+  - [华为云](https://huaweicloud.com/) ([配置指南](doc/providers/huaweidns.md)) (@cybmp3) ⚡
+  - [NameSilo](https://www.namesilo.com/) ([配置指南](doc/providers/namesilo.md))
   - [腾讯云](https://cloud.tencent.com/) ([配置指南](doc/providers/tencentcloud.md)) ⚡
+  - [腾讯云 EdgeOne](https://cloud.tencent.com/product/teo) ([配置指南](doc/providers/edgeone.md)) ⚡
+  - [No-IP](https://www.noip.com/) ([配置指南](doc/providers/noip.md))
   - 自定义回调 API ([配置指南](doc/providers/callback.md))
   
   > ⚡ 标记的服务商使用高级 HMAC-SHA256 签名认证，提供企业级安全保障
@@ -161,12 +165,16 @@ Dynamic: license-file
 
    - **DNSPOD(中国版)**: [创建 token](https://support.dnspod.cn/Kb/showarticle/tsid/227/) | [详细配置文档](doc/providers/dnspod.md)
    - **阿里云 DNS**: [申请 accesskey](https://help.aliyun.com/document_detail/87745.htm) | [详细配置文档](doc/providers/alidns.md)
-   - **DNS.COM**: [API Key/Secret](https://www.dns.com/member/apiSet)
-   - **DNSPOD(国际版)**: [获取 token](https://www.dnspod.com/docs/info.html#get-the-user-token)
-   - **CloudFlare**: [API Key](https://support.cloudflare.com/hc/en-us/articles/200167836-Where-do-I-find-my-Cloudflare-API-key-)（除了 `email + API KEY`，也可使用 `Token`，**需要list Zone 权限**）
-   - **HE.net**: [DDNS 文档](https://dns.he.net/docs.html)（仅需将设置的密码填入 `token` 字段，`id` 字段可留空）
-   - **华为云 DNS**: [APIKEY 申请](https://console.huaweicloud.com/iam/)（点左边访问密钥，然后点新增访问密钥）
+   - **阿里云边缘安全加速(ESA)**: [申请 accesskey](https://help.aliyun.com/document_detail/87745.htm) | [详细配置文档](doc/providers/aliesa.md)
+   - **51DNS(dns.com)**: [API Key/Secret](https://www.dns.com/member/apiSet) | [详细配置文档](doc/providers/51dns.md)
+   - **DNSPOD(国际版)**: [获取 token](https://www.dnspod.com/docs/info.html#get-the-user-token) | [详细配置文档](doc/providers/dnspod_com.md)
+   - **CloudFlare**: [API Key](https://support.cloudflare.com/hc/en-us/articles/200167836-Where-do-I-find-my-Cloudflare-API-key-)（除了 `email + API KEY`，也可使用 `Token`，**需要list Zone 权限**） | [详细配置文档](doc/providers/cloudflare.md)
+   - **HE.net**: [DDNS 文档](https://dns.he.net/docs.html)（仅需将设置的密码填入 `token` 字段，`id` 字段可留空） | [详细配置文档](doc/providers/he.md)
+   - **华为云 DNS**: [APIKEY 申请](https://console.huaweicloud.com/iam/)（点左边访问密钥，然后点新增访问密钥） | [详细配置文档](doc/providers/huaweidns.md)
+   - **NameSilo**: [API Key](https://www.namesilo.com/account/api-manager)（API Manager 中获取 API Key） | [详细配置文档](doc/providers/namesilo.md)
    - **腾讯云 DNS**: [详细配置文档](doc/providers/tencentcloud.md)
+   - **腾讯云 EdgeOne**: [详细配置文档](doc/providers/edgeone.md)
+   - **No-IP**: [用户名和密码](https://www.noip.com/)（使用 No-IP 账户的用户名和密码） | [详细配置文档](doc/providers/noip.md)
    - **自定义回调**: 参数填写方式请查看下方的自定义回调配置说明
 
 2. 修改配置文件，`ipv4` 和 `ipv6` 字段，为待更新的域名，详细参照配置说明
@@ -217,7 +225,7 @@ python -m ddns -c /path/to/config.json
 | :----: | :----------------: | :------: | :---------: | :----------------: | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 |   id   |       string       |    √     |     无      |    api 访问 ID     | Cloudflare 为邮箱（使用 Token 时留空）<br>HE.net 可留空<br>华为云为 Access Key ID (AK)                                                                                                   |
 | token  |       string       |    √     |     无      |   api 授权 token   | 部分平台叫 secret key，**反馈粘贴时删除**                                                                                                                                                |
-|  dns   |       string       |    No    | `"dnspod"`  |     dns 服务商     | 阿里 DNS 为 `alidns`，Cloudflare 为 `cloudflare`，dns.com 为 `dnscom`，DNSPOD 国内为 `dnspod`，DNSPOD 国际为 `dnspod_com`，HE.net 为 `he`，华为云为 `huaweidns`，腾讯云为 `tencentcloud`，自定义回调为 `callback`。部分服务商有[详细配置文档](doc/providers/) |
+|  dns   |       string       |    No    | `"dnspod"`  |     dns 服务商     | 阿里 DNS 为 `alidns`，阿里ESA为 `aliesa`，Cloudflare 为 `cloudflare`，dns.com 为 `dnscom`，DNSPOD 国内为 `dnspod`，DNSPOD 国际为 `dnspod_com`，HE.net 为 `he`，华为云为 `huaweidns`，NameSilo 为 `namesilo`，腾讯云为 `tencentcloud`，腾讯云EdgeOne为 `edgeone`，No-IP 为 `noip`，自定义回调为 `callback`。部分服务商有[详细配置文档](doc/providers/) |
 |  ipv4  |       array        |    No    |    `[]`     |   ipv4 域名列表    | 为 `[]` 时，不会获取和更新 IPv4 地址                                                                                                                                                     |
 |  ipv6  |       array        |    No    |    `[]`     |   ipv6 域名列表    | 为 `[]` 时，不会获取和更新 IPv6 地址                                                                                                                                                     |
 | index4 | string\|int\|array |    No    | `"default"` |   ipv4 获取方式    | 可设置 `网卡`、`内网`、`公网`、`正则` 等方式                                                                                                                                             |
@@ -266,7 +274,7 @@ python -m ddns -c /path/to/config.json
   "$schema": "https://ddns.newfuture.cc/schema/v4.0.json",
   "id": "12345",
   "token": "mytokenkey",
-  "dns": "dnspod 或 dnspod_com 或 alidns 或 dnscom 或 cloudflare 或 he 或 huaweidns 或 tencentcloud 或 callback",
+  "dns": "dnspod 或 dnspod_com 或 alidns 或 aliesa 或 dnscom 或 cloudflare 或 he 或 huaweidns 或 namesilo 或 tencentcloud 或 noip 或 callback",
   "ipv4": ["ddns.newfuture.cc", "ipv4.ddns.newfuture.cc"],
   "ipv6": ["ddns.newfuture.cc", "ipv6.ddns.newfuture.cc"],
   "index4": 0,
@@ -330,6 +338,7 @@ Docker 镜像在无额外参数的情况下，已默认启用每 5 分钟执行
 使用系统自带的 IE 浏览器访问一次对应的 API 即可
 
 - alidns 打开: <https://alidns.aliyuncs.com>
+- aliesa 打开: <https://esa.cn-hangzhou.aliyuncs.com>
 - cloudflare 打开: <https://api.cloudflare.com>
 - dns.com 打开: <https://www.dns.com>
 - dnspod.cn 打开: <https://dnsapi.cn>

ddns-4.1.0b2.dist-info/RECORD

@@ -0,0 +1,31 @@
+ddns/__builtins__.pyi,sha256=QTTtckbWAAZasu-uzeeyK4MLj9S9dxLtRlhty6U01jQ,109
+ddns/__init__.py,sha256=SUqnkj9QXJFuc7vXN63wohdxYu2OupGgfTyZYYtO-uI,258
+ddns/__main__.py,sha256=PrkwVahIUGvT9CNy3uXs8ZX-ox2RVx72aeWexhl6YZM,4134
+ddns/cache.py,sha256=A1s3rnOJbPrGEjbGbbISrVg46lZFzZ84WPdzHaCtYBk,5971
+ddns/ip.py,sha256=K4iFWwBX9kSrULVdNGX17dc_Zbqy9VpmpP2mdU_h6Cc,3947
+ddns/provider/__init__.py,sha256=qAw-R-l7nUA9L96Tmr2n-T7_g8T9Mah7u615yg2zScY,2793
+ddns/provider/_base.py,sha256=X73ID1iyz11zCX2nQne-8i7xW5CPGIXuWSs2zFI_Al8,20810
+ddns/provider/_signature.py,sha256=fF8XxMDkXjia96d1gIVYWc72MVVe65AAnD7qr51qKXA,4140
+ddns/provider/alidns.py,sha256=sBwDrtARbqgfEynPyR-dVfAVeh4K6lhO1XL9_0C1Tig,6096
+ddns/provider/aliesa.py,sha256=5tGPyW22TtI7AGJKugIOipby3R68bHHEJiR_k9og1Rs,4695
+ddns/provider/callback.py,sha256=WSd8QNpWUUJXQbyIatANmyigLU6VBvrLBsn7lALz8yA,2924
+ddns/provider/cloudflare.py,sha256=0sVelYFU3ndjREQjtQAaT6G3jxj1Stk3hN7bT_NAUpI,4484
+ddns/provider/debug.py,sha256=3TZYcXHcIzTwUEj5_rvZTT0QqS6jFwTuBS7cMujG2tM,587
+ddns/provider/dnscom.py,sha256=IfdX_HaEjH12NHxdv6taRiX-zLQTo4kpBrJ1VWE9au4,3667
+ddns/provider/dnspod.py,sha256=CSAIJYIjna-PphR4KE9KlMsPcgfEyRnJPCIEDqYlzNg,4445
+ddns/provider/dnspod_com.py,sha256=uTFBSJIlFAijbpXYvte_pQHpGvTR4co9mEkJ0prRq7s,398
+ddns/provider/edgeone.py,sha256=ck8GkkOk-Wa01QoGoPfD2pr6ok7gLuQyB7TDsSyNtHE,3897
+ddns/provider/he.py,sha256=v6x_2_iJBr1RMefaBgnn3TWNk8-JxcL3llxmxr1vz1w,1820
+ddns/provider/huaweidns.py,sha256=LH6EiCzGuftg3dNk7ZiPLaS6BvM0vWydrRXhtaLxj04,5590
+ddns/provider/namesilo.py,sha256=jgqkQUcHVCyVjYoxazmcN9Gu_Zd-EAv3aSnNmHHJ1jk,5843
+ddns/provider/noip.py,sha256=JY2939xCu0hF6wl1QPZpxz-2TgwYVY0GWMY97iRVHME,3961
+ddns/provider/tencentcloud.py,sha256=SzQlTVU9W3NRq4QvK88eP4A3y6g13M0Ud-AE93qvSQ8,7153
+ddns/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ddns/util/comment.py,sha256=_B8sRpCJksNspsdld4ha03W1TAi-MyPRK7pL7ym0j9k,2199
+ddns/util/http.py,sha256=xG5QyRO8r-pCnF4YBfGs_UxqUamX_f3n_wshw6FlMqM,7664
+ddns-4.1.0b2.dist-info/licenses/LICENSE,sha256=MI-ECjp-Vl7WZLiSPY6r5VwrOReNiICVB1QCXiUGt_s,1111
+ddns-4.1.0b2.dist-info/METADATA,sha256=bwPvJGxEL0JEahaLk3PD4gI04tZdVUpAJQQMKH0xP68,20807
+ddns-4.1.0b2.dist-info/WHEEL,sha256=JNWh1Fm1UdwIQV075glCn4MVuCRs0sotJIq-J6rbxCU,109
+ddns-4.1.0b2.dist-info/entry_points.txt,sha256=2-VbA-WZcjebkZrGKvUCuBBRYF4xQNMoLIoGaS234WU,44
+ddns-4.1.0b2.dist-info/top_level.txt,sha256=Se0wn3T8Bc4pj55dGwVrCe8BFwmFCBwQVHF1bTyV0o0,5
+ddns-4.1.0b2.dist-info/RECORD,,