requrst 0.5.0__tar.gz → 2.0.0__tar.gz

{requrst-0.5.0 → requrst-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: requrst
-Version: 0.5.0
+Version: 2.0.0
 Summary: 纯Python Socket手写HTTP/HTTPS客户端，零第三方依赖，第二方自研请求库
 Home-page: 
 Author: 

requrst-2.0.0/requrst/__init__.py

@@ -0,0 +1,14 @@
+from .core import (
+    get, post, Session, Response, RequestContext,
+    register_before_request, extract_html_text, send_email,
+    DEFAULT_VERIFY, DEFAULT_TIMEOUT, DEFAULT_RETRY,
+    DEFAULT_MAX_REDIRECTS, DEFAULT_HEADERS
+)
+
+__version__ = "2.0.0"
+__all__ = [
+    "get", "post", "Session", "Response", "RequestContext",
+    "register_before_request", "extract_html_text", "send_email",
+    "DEFAULT_VERIFY", "DEFAULT_TIMEOUT", "DEFAULT_RETRY",
+    "DEFAULT_MAX_REDIRECTS", "DEFAULT_HEADERS"
+]

requrst-2.0.0/requrst/core.py

@@ -0,0 +1,333 @@
+import socket
+import ssl
+import json
+import re
+from urllib.parse import urlparse, urlencode
+import base64
+
+DEFAULT_HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+    "Connection": "close"
+}
+DEFAULT_TIMEOUT = 10
+DEFAULT_RETRY = 1
+DEFAULT_MAX_REDIRECTS = 3
+DEFAULT_VERIFY = True
+
+def recv_smtp_line(sock):
+    resp = b""
+    while True:
+        chunk = sock.recv(1)
+        if not chunk:
+            break
+        resp += chunk
+        if resp.endswith(b"\n"):
+            break
+    return resp.decode("utf-8", errors="ignore").strip()
+
+def recv_smtp_multiline(sock):
+    lines = []
+    while True:
+        line = recv_smtp_line(sock)
+        lines.append(line)
+        if not line.startswith("250-"):
+            break
+    return "\n".join(lines)
+
+def _parse_chunked_body(data: bytes) -> bytes:
+    result = b""
+    offset = 0
+    while True:
+        crlf_pos = data.find(b"\r\n", offset)
+        if crlf_pos == -1:
+            break
+        chunk_size_hex = data[offset:crlf_pos].decode("ascii").strip()
+        try:
+            chunk_size = int(chunk_size_hex, 16)
+        except ValueError:
+            break
+        offset = crlf_pos + 2
+        if chunk_size == 0:
+            break
+        result += data[offset:offset + chunk_size]
+        offset += chunk_size + 2
+    return result
+
+class Response:
+    def __init__(self, status_code: int, headers: dict, content: bytes):
+        self.status_code = status_code
+        self.headers = {k.lower(): v for k, v in headers.items()}
+        self.content = content
+        self.encoding = self._auto_detect_encoding()
+
+    @property
+    def text(self):
+        return self.content.decode(self.encoding, errors="ignore")
+
+    def _auto_detect_encoding(self):
+        content_type = self.headers.get("content-type", "")
+        if "charset=" in content_type:
+            charset = content_type.split("charset=")[1].split(";")[0].strip().lower()
+            return charset
+        try:
+            self.content.decode("utf-8")
+            return "utf-8"
+        except UnicodeDecodeError:
+            return "gbk"
+
+    def json(self):
+        return json.loads(self.text)
+
+    def text_only(self):
+        text = re.sub(r"<script.*?</script>", "", self.text, flags=re.S | re.I)
+        text = re.sub(r"<style.*?</style>", "", text, flags=re.S | re.I)
+        text = re.sub(r"<!--.*?-->", "", text, flags=re.S)
+        text = re.sub(r"<.*?>", "", text)
+        text = re.sub(r"\s+", " ", text).strip()
+        return text
+
+class RequestContext:
+    def __init__(self, url: str, method: str, headers: dict, timeout: int):
+        self.url = url
+        self.method = method
+        self.headers = headers
+        self.timeout = timeout
+
+before_request_hooks = []
+
+def register_before_request(func):
+    before_request_hooks.append(func)
+
+def _run_before_intercept(ctx: RequestContext):
+    for hook in before_request_hooks:
+        hook(ctx)
+
+def _socket_request(host, path, port, scheme, method, headers, body=b"", timeout=10, verify=True, retry=1, max_redirects=3):
+    for attempt in range(retry + 1):
+        sock = None
+        try:
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.settimeout(timeout)
+
+            if scheme == "https":
+                ctx = ssl.create_default_context() if verify else ssl._create_unverified_context()
+                sock = ctx.wrap_socket(sock, server_hostname=host)
+
+            sock.connect((host, port))
+
+            req_lines = [f"{method} {path} HTTP/1.1", f"Host: {host}"]
+            for k, v in headers.items():
+                req_lines.append(f"{k}: {v}")
+            if body:
+                req_lines.append(f"Content-Length: {len(body)}")
+            req_lines.append("")
+            req_data = "\r\n".join(req_lines).encode("utf-8") + body
+            sock.sendall(req_data)
+
+            sock_file = sock.makefile("rb")
+            status_line = sock_file.readline().decode("utf-8").strip()
+            parts = status_line.split()
+            status_code = int(parts[1]) if len(parts) > 1 else 0
+
+            headers_dict = {}
+            while True:
+                line = sock_file.readline().decode("utf-8").strip()
+                if not line:
+                    break
+                if ": " in line:
+                    k, v = line.split(": ", 1)
+                    headers_dict[k] = v
+
+            transfer_encoding = headers_dict.get("Transfer-Encoding", "").lower()
+            if transfer_encoding == "chunked":
+                chunked_data = b""
+                while True:
+                    line = sock_file.readline().decode("utf-8").strip()
+                    if not line:
+                        break
+                    chunk_size = int(line, 16)
+                    if chunk_size == 0:
+                        sock_file.readline()
+                        break
+                    chunk = sock_file.read(chunk_size)
+                    chunked_data += chunk
+                    sock_file.readline()
+                body_part = chunked_data
+            else:
+                content_length = headers_dict.get("Content-Length")
+                if content_length:
+                    body_part = sock_file.read(int(content_length))
+                else:
+                    body_part = sock_file.read()
+            sock_file.close()
+            sock.close()
+
+            if status_code in (301, 302, 303, 307, 308) and max_redirects > 0:
+                location = headers_dict.get("Location", "")
+                if location:
+                    parsed = urlparse(location)
+                    if not parsed.netloc:
+                        location = f"{scheme}://{host}{location if location.startswith('/') else '/' + location}"
+                    new_method = "GET" if status_code in (302, 303) else method
+                    return _request(location, new_method, headers, body if new_method != "GET" else b"",
+                                   timeout, verify, retry, max_redirects - 1)
+
+            return Response(status_code, headers_dict, body_part)
+
+        except (socket.timeout, ConnectionError, ssl.SSLError) as e:
+            if sock:
+                sock.close()
+            if attempt == retry:
+                return Response(0, {}, f"Request Failed: {str(e)}".encode())
+            continue
+        except Exception as e:
+            if sock:
+                sock.close()
+            return Response(0, {}, f"Request Error: {str(e)}".encode())
+
+def _request(url, method, headers=None, body=b"", timeout=10, verify=True, retry=1, max_redirects=3):
+    parsed = urlparse(url)
+    host = parsed.hostname
+    port = parsed.port or (443 if parsed.scheme == "https" else 80)
+    path = parsed.path or "/"
+    if parsed.query:
+        path += "?" + parsed.query
+
+    req_headers = DEFAULT_HEADERS.copy()
+    if headers:
+        req_headers.update(headers)
+    if "Host" not in req_headers:
+        req_headers["Host"] = host
+
+    ctx = RequestContext(url, method, req_headers, timeout)
+    _run_before_intercept(ctx)
+
+    return _socket_request(host, path, port, parsed.scheme, method,
+                          ctx.headers, body, timeout, verify, retry, max_redirects)
+
+class Session:
+    def __init__(self):
+        self.cookies = {}
+        self.headers = DEFAULT_HEADERS.copy()
+        self.timeout = DEFAULT_TIMEOUT
+        self.retry = DEFAULT_RETRY
+        self.max_redirects = DEFAULT_MAX_REDIRECTS
+        self.verify = DEFAULT_VERIFY
+
+    def _update_cookies(self, resp_headers):
+        set_cookie = resp_headers.get("Set-Cookie", "")
+        if not set_cookie:
+            return
+        for cookie in set_cookie.split(", "):
+            if "=" in cookie:
+                key_val = cookie.split(";")[0]
+                if "=" in key_val:
+                    k, v = key_val.split("=", 1)
+                    self.cookies[k.strip()] = v.strip()
+
+    def _build_cookie_header(self):
+        return "; ".join([f"{k}={v}" for k, v in self.cookies.items()]) if self.cookies else ""
+
+    def request(self, method, url, params=None, data=None, json_data=None, headers=None, **kwargs):
+        if params:
+            query = urlencode(params)
+            url += f"&{query}" if "?" in url else f"?{query}"
+
+        req_headers = self.headers.copy()
+        if headers:
+            req_headers.update(headers)
+
+        cookie_header = self._build_cookie_header()
+        if cookie_header:
+            req_headers["Cookie"] = cookie_header
+
+        body = b""
+        if json_data:
+            req_headers["Content-Type"] = "application/json; charset=utf-8"
+            body = json.dumps(json_data).encode("utf-8")
+        elif data:
+            req_headers["Content-Type"] = "application/x-www-form-urlencoded; charset=utf-8"
+            body = urlencode(data).encode("utf-8")
+
+        timeout = kwargs.get("timeout", self.timeout)
+        verify = kwargs.get("verify", self.verify)
+        retry = kwargs.get("retry", self.retry)
+        max_redirects = kwargs.get("max_redirects", self.max_redirects)
+
+        resp = _request(url, method, req_headers, body, timeout, verify, retry, max_redirects)
+        self._update_cookies(resp.headers)
+        return resp
+
+    def get(self, url, params=None, headers=None, **kwargs):
+        return self.request("GET", url, params=params, headers=headers, **kwargs)
+
+    def post(self, url, data=None, json_data=None, headers=None, **kwargs):
+        return self.request("POST", url, data=data, json_data=json_data, headers=headers, **kwargs)
+
+def get(url, params=None, headers=None, **kwargs):
+    return Session().get(url, params=params, headers=headers, **kwargs)
+
+def post(url, data=None, json_data=None, headers=None, **kwargs):
+    return Session().post(url, data=data, json_data=json_data, headers=headers, **kwargs)
+
+def extract_html_text(html: str) -> str:
+    text = re.sub(r"<script.*?</script>", "", html, flags=re.S | re.I)
+    text = re.sub(r"<style.*?</style>", "", text, flags=re.S | re.I)
+    text = re.sub(r"<!--.*?-->", "", text, flags=re.S)
+    text = re.sub(r"<.*?>", "", text)
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
+
+def send_email(smtp_server, smtp_port, sender_email, sender_pwd, to_email, subject, content):
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        ctx = ssl.create_default_context()
+        ssl_sock = ctx.wrap_socket(sock, server_hostname=smtp_server)
+        ssl_sock.connect((smtp_server, smtp_port))
+
+        recv_smtp_line(ssl_sock)
+        ssl_sock.send(b"EHLO client\r\n")
+        recv_smtp_multiline(ssl_sock)
+
+        ssl_sock.send(b"AUTH LOGIN\r\n")
+        resp = recv_smtp_line(ssl_sock)
+        if not resp.startswith("334"):
+            return False, "服务器不支持 AUTH LOGIN"
+
+        ssl_sock.send(base64.b64encode(sender_email.encode()) + b"\r\n")
+        resp = recv_smtp_line(ssl_sock)
+        if not resp.startswith("334"):
+            return False, "用户名被拒绝"
+
+        ssl_sock.send(base64.b64encode(sender_pwd.encode()) + b"\r\n")
+        resp = recv_smtp_line(ssl_sock)
+        if not resp.startswith("235"):
+            return False, "密码错误或认证失败"
+
+        ssl_sock.send(f"MAIL FROM:<{sender_email}>\r\n".encode())
+        resp = recv_smtp_line(ssl_sock)
+        if not resp.startswith("250"):
+            return False, f"发件人地址被拒绝: {resp}"
+
+        ssl_sock.send(f"RCPT TO:<{to_email}>\r\n".encode())
+        resp = recv_smtp_line(ssl_sock)
+        if not resp.startswith("250"):
+            return False, f"收件人地址被拒绝: {resp}"
+
+        ssl_sock.send(b"DATA\r\n")
+        resp = recv_smtp_line(ssl_sock)
+        if not resp.startswith("354"):
+            return False, "服务器拒绝接收数据"
+
+        msg = f"From: {sender_email}\r\nTo: {to_email}\r\nSubject: {subject}\r\nContent-Type: text/plain; charset=utf-8\r\n\r\n{content}\r\n.\r\n"
+        ssl_sock.send(msg.encode())
+        resp = recv_smtp_line(ssl_sock)
+        if not resp.startswith("250"):
+            return False, f"邮件发送失败: {resp}"
+
+        ssl_sock.send(b"QUIT\r\n")
+        ssl_sock.close()
+        return True, "邮件发送成功"
+    except Exception as e:
+        return False, f"发送失败: {str(e)}"

{requrst-0.5.0 → requrst-2.0.0}/requrst.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: requrst
-Version: 0.5.0
+Version: 2.0.0
 Summary: 纯Python Socket手写HTTP/HTTPS客户端，零第三方依赖，第二方自研请求库
 Home-page: 
 Author: 

{requrst-0.5.0 → requrst-2.0.0}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="requrst",
-    version="0.5.0",
+    version="2.0.0",
     author="",
     author_email="",
     description="纯Python Socket手写HTTP/HTTPS客户端，零第三方依赖，第二方自研请求库",

requrst-0.5.0/requrst/__init__.py

@@ -1,17 +0,0 @@
-from .core import (
-    get,
-    post,
-    Session,
-    Response,
-    RequestContext,
-    register_before_request,
-    extract_html_text,
-    send_email,
-    DEFAULT_VERIFY,
-    DEFAULT_TIMEOUT,
-    DEFAULT_RETRY,
-    DEFAULT_MAX_REDIRECTS
-)
-
-__version__ = "0.5.0"
-

requrst-0.5.0/requrst/core.py

@@ -1,303 +0,0 @@
-import socket
-import ssl
-import json
-import re
-from urllib.parse import urlparse, urlencode
-import smtplib
-from email.mime.text import MIMEText
-from email.mime.multipart import MIMEMultipart
-
-DEFAULT_HEADERS = {
-    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
-    "Connection": "close"
-}
-DEFAULT_TIMEOUT = 10
-DEFAULT_RETRY = 1
-DEFAULT_MAX_REDIRECTS = 3
-DEFAULT_VERIFY = True
-
-class RequestContext:
-    def __init__(self, url: str, method: str, headers: dict, timeout: int):
-        self.url = url
-        self.method = method
-        self.headers = headers
-        self.timeout = timeout
-
-class Response:
-    def __init__(self, status_code: int, headers: dict, content: bytes):
-        self.status_code = status_code
-        self.headers = headers
-        self.content = content
-        self.encoding = self._auto_detect_encoding()
-
-    @property
-    def text(self):
-        return self.content.decode(self.encoding, errors="ignore")
-
-    def _auto_detect_encoding(self):
-        content_type = self.headers.get("content-type", "")
-        if "charset=" in content_type:
-            charset = content_type.split("charset=")[1].split(";")[0].strip().lower()
-            return charset
-        try:
-            self.content.decode("utf-8")
-            return "utf-8"
-        except UnicodeDecodeError:
-            return "gbk"
-
-    def json(self):
-        return json.loads(self.text)
-
-    def text_only(self):
-        text = re.sub(r"<script.*?</script>", "", self.text, flags=re.S | re.I)
-        text = re.sub(r"<style.*?</style>", "", text, flags=re.S | re.I)
-        text = re.sub(r"<!--.*?-->", "", text, flags=re.S)
-        text = re.sub(r"<.*?>", "", text)
-        text = re.sub(r"\s+", " ", text).strip()
-        return text
-
-before_request_hooks = []
-
-def register_before_request(func):
-    before_request_hooks.append(func)
-
-def _run_before_intercept(ctx: RequestContext):
-    for hook in before_request_hooks:
-        hook(ctx)
-
-def _parse_chunked_body(data: bytes) -> bytes:
-    result = b""
-    offset = 0
-    while True:
-        crlf_pos = data.find(b"\r\n", offset)
-        if crlf_pos == -1:
-            break
-        chunk_size_hex = data[offset:crlf_pos].decode("ascii").strip()
-        chunk_size = int(chunk_size_hex, 16)
-        offset = crlf_pos + 2
-        if chunk_size == 0:
-            break
-        result += data[offset:offset+chunk_size]
-        offset += chunk_size + 2
-    return result
-
-def _socket_request(
-    host, path, port, scheme, method, headers, body=b"",
-    timeout=10, verify=DEFAULT_VERIFY, retry=1, max_redirects=3
-):
-    for attempt in range(retry + 1):
-        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        sock.settimeout(timeout)
-        try:
-            if scheme == "https":
-                context = ssl.create_default_context() if verify else ssl._create_unverified_context()
-                sock = context.wrap_socket(sock, server_hostname=host)
-
-            sock.connect((host, port))
-
-            req_lines = [f"{method} {path} HTTP/1.1", f"Host: {host}"]
-            for k, v in headers.items():
-                req_lines.append(f"{k}: {v}")
-            if body:
-                req_lines.append(f"Content-Length: {len(body)}")
-            req_lines.append("")
-
-            req_data = "\r\n".join(req_lines).encode("utf-8") + body
-            sock.sendall(req_data)
-
-            resp_data = b""
-            while True:
-                chunk = sock.recv(4096)
-                if not chunk:
-                    break
-                resp_data += chunk
-            sock.close()
-
-            header_end = resp_data.find(b"\r\n\r\n")
-            if header_end == -1:
-                raise Exception("Invalid HTTP response")
-            header_part = resp_data[:header_end].decode("utf-8", errors="ignore")
-            body_part = resp_data[header_end+4:]
-
-            first_line = header_part.splitlines()[0]
-            status_code = int(first_line.split()[1])
-
-            resp_headers = {}
-            for line in header_part.splitlines()[1:]:
-                if ": " in line:
-                    k, v = line.split(": ", 1)
-                    resp_headers[k.strip().lower()] = v.strip()
-
-            if resp_headers.get("transfer-encoding", "").lower() == "chunked":
-                body_part = _parse_chunked_body(body_part)
-
-            if status_code in (301, 302) and max_redirects > 0:
-                location = resp_headers.get("location", "")
-                if not location:
-                    break
-
-                new_method = "GET"
-                new_body = b""
-
-                redirect_url = urlparse(location)
-                if not redirect_url.netloc:
-                    redirect_url = urlparse(f"{scheme}://{host}{location}")
-                hp = redirect_url.netloc.split(":")
-                rh = hp[0]
-                rp = int(hp[1]) if len(hp) > 1 else (443 if redirect_url.scheme == "https" else 80)
-                return _socket_request(
-                    rh,
-                    redirect_url.path or "/",
-                    rp,
-                    redirect_url.scheme,
-                    new_method, headers, new_body,
-                    timeout, verify, retry, max_redirects-1
-                )
-
-            return Response(status_code, resp_headers, body_part)
-
-        except (socket.timeout, ConnectionError, ssl.SSLError) as e:
-            sock.close()
-            if attempt == retry:
-                return Response(0, {}, f"Request Failed: {str(e)}".encode("utf-8"))
-            continue
-        except Exception as e:
-            sock.close()
-            return Response(0, {}, f"Request Error: {str(e)}".encode("utf-8"))
-
-class Session:
-    def __init__(self):
-        self.cookies = {}
-        self.headers = DEFAULT_HEADERS.copy()
-        self.timeout = DEFAULT_TIMEOUT
-        self.retry = DEFAULT_RETRY
-        self.max_redirects = DEFAULT_MAX_REDIRECTS
-        self.verify = DEFAULT_VERIFY
-
-    def _update_cookies(self, resp_headers):
-        set_cookie = resp_headers.get("set-cookie", "")
-        if not set_cookie:
-            return
-        for cookie in set_cookie.split(", "):
-            if "=" in cookie:
-                key_val = cookie.split(";")[0]
-                if "=" in key_val:
-                    k, v = key_val.split("=", 1)
-                    self.cookies[k.strip()] = v.strip()
-
-    def _build_cookie_header(self):
-        return "; ".join([f"{k}={v}" for k, v in self.cookies.items()]) if self.cookies else ""
-
-    def get(self, url: str, params: dict = None, headers: dict = None, **kwargs) -> Response:
-        if params:
-            query = urlencode(params)
-            url += f"&{query}" if "?" in url else f"?{query}"
-
-        req_headers = self.headers.copy()
-        if headers:
-            req_headers.update(headers)
-        cookie_header = self._build_cookie_header()
-        if cookie_header:
-            req_headers["Cookie"] = cookie_header
-
-        ctx = RequestContext(url, "GET", req_headers, kwargs.get("timeout", self.timeout))
-        _run_before_intercept(ctx)
-
-        parsed = urlparse(ctx.url)
-        host_port = parsed.netloc.split(":")
-        host = host_port[0]
-        port = int(host_port[1]) if len(host_port) > 1 else (443 if parsed.scheme == "https" else 80)
-        path = parsed.path if parsed.path else "/"
-        if parsed.query:
-            path += "?" + parsed.query
-        scheme = parsed.scheme
-
-        resp = _socket_request(
-            host, path, port, scheme, "GET", ctx.headers, b"",
-            timeout=kwargs.get("timeout", self.timeout),
-            verify=kwargs.get("verify", self.verify),
-            retry=kwargs.get("retry", self.retry),
-            max_redirects=kwargs.get("max_redirects", self.max_redirects)
-        )
-        self._update_cookies(resp.headers)
-        return resp
-
-    def post(self, url: str, data: dict = None, json_data: dict = None, headers: dict = None, **kwargs) -> Response:
-        req_headers = self.headers.copy()
-        if headers:
-            req_headers.update(headers)
-        cookie_header = self._build_cookie_header()
-        if cookie_header:
-            req_headers["Cookie"] = cookie_header
-
-        body = b""
-        if json_data:
-            req_headers["Content-Type"] = "application/json; charset=utf-8"
-            body = json.dumps(json_data).encode("utf-8")
-        elif data:
-            req_headers["Content-Type"] = "application/x-www-form-urlencoded; charset=utf-8"
-            body = urlencode(data).encode("utf-8")
-
-        ctx = RequestContext(url, "POST", req_headers, kwargs.get("timeout", self.timeout))
-        _run_before_intercept(ctx)
-
-        parsed = urlparse(ctx.url)
-        host_port = parsed.netloc.split(":")
-        host = host_port[0]
-        port = int(host_port[1]) if len(host_port) > 1 else (443 if parsed.scheme == "https" else 80)
-        path = parsed.path if parsed.path else "/"
-        if parsed.query:
-            path += "?" + parsed.query
-        scheme = parsed.scheme
-
-        resp = _socket_request(
-            host, path, port, scheme, "POST", ctx.headers, body,
-            timeout=kwargs.get("timeout", self.timeout),
-            verify=kwargs.get("verify", self.verify),
-            retry=kwargs.get("retry", self.retry),
-            max_redirects=kwargs.get("max_redirects", self.max_redirects)
-        )
-        self._update_cookies(resp.headers)
-        return resp
-
-def get(url: str, params: dict = None, headers: dict = None, **kwargs) -> Response:
-    return Session().get(url, params, headers,** kwargs)
-
-def post(url: str, data: dict = None, json_data: dict = None, headers: dict = None, **kwargs) -> Response:
-    return Session().post(url, data, json_data, headers, **kwargs)
-
-def extract_html_text(html: str) -> str:
-    text = re.sub(r"<script.*?</script>", "", html, flags=S | re.I)
-    text = re.sub(r"<style.*?</style>", "", text, flags=re.S | re.I)
-    text = re.sub(r"<!--.*?-->", "", text, flags=re.S)
-    text = re.sub(r"<.*?>", "", text)
-    text = re.sub(r"\s+", " ", text).strip()
-    return text
-
-def send_email(
-    smtp_server: str,
-    smtp_port: int,
-    sender_email: str,
-    sender_pwd: str,
-    to_email: str,
-    subject: str,
-    content: str
-):
-    msg = MIMEMultipart()
-    msg["From"] = sender_email
-    msg["To"] = to_email
-    msg["Subject"] = subject
-    msg.attach(MIMEText(content, "plain", "utf-8"))
-
-    try:
-        if smtp_port == 465:
-            server = smtplib.SMTP_SSL(smtp_server, smtp_port)
-        else:
-            server = smtplib.SMTP(smtp_server, smtp_port)
-            server.starttls()
-        server.login(sender_email, sender_pwd)
-        server.sendmail(sender_email, to_email, msg.as_string())
-        server.quit()
-        return True, "邮件发送成功"
-    except Exception as e:
-        return False, f"发送失败: {str(e)}"