hutool-python 1.0.0__py3-none-any.whl

hutool/extra/qr_code_util.py

@@ -0,0 +1,58 @@
+"""二维码工具类，基于qrcode"""
+
+import io
+
+import qrcode
+from PIL import Image
+
+
+class QrCodeUtil:
+    """二维码工具类，基于qrcode"""
+
+    @staticmethod
+    def generate(content: str, width: int = 300, height: int = 300) -> Image.Image:
+        """生成二维码，返回PIL Image对象
+
+        :param content: 二维码内容
+        :param width: 图片宽度（像素）
+        :param height: 图片高度（像素）
+        :return: PIL Image对象
+        """
+        qr = qrcode.QRCode(
+            version=None,
+            error_correction=qrcode.constants.ERROR_CORRECT_H,
+            box_size=10,
+            border=4,
+        )
+        qr.add_data(content)
+        qr.make(fit=True)
+        img = qr.make_image(fill_color="black", back_color="white")
+        img = img.resize((width, height), Image.LANCZOS)
+        return img
+
+    @staticmethod
+    def generate_as_bytes(content: str, width: int = 300, height: int = 300, fmt: str = "png") -> bytes:
+        """生成二维码并返回字节数组
+
+        :param content: 二维码内容
+        :param width: 图片宽度（像素）
+        :param height: 图片高度（像素）
+        :param fmt: 图片格式，默认为 'png'
+        :return: 图片字节数组
+        """
+        img = QrCodeUtil.generate(content, width, height)
+        buf = io.BytesIO()
+        img.save(buf, format=fmt.upper())
+        return buf.getvalue()
+
+    @staticmethod
+    def generate_to_file(content: str, path: str, width: int = 300, height: int = 300) -> None:
+        """生成二维码并保存到文件
+
+        :param content: 二维码内容
+        :param path: 输出文件路径
+        :param width: 图片宽度（像素）
+        :param height: 图片高度（像素）
+        """
+        img = QrCodeUtil.generate(content, width, height)
+        img.save(path)

hutool/extra/template_util.py

@@ -0,0 +1,41 @@
+"""模板工具类，基于jinja2"""
+
+import os
+from typing import Optional
+
+from jinja2 import BaseLoader, Environment, FileSystemLoader, StrictUndefined
+
+
+class TemplateUtil:
+    """模板工具类，基于jinja2"""
+
+    @staticmethod
+    def render(template_str: str, context: Optional[dict] = None) -> str:
+        """渲染模板字符串
+
+        :param template_str: 模板字符串
+        :param context: 上下文变量字典
+        :return: 渲染后的字符串
+        """
+        if context is None:
+            context = {}
+        env = Environment(loader=BaseLoader(), undefined=StrictUndefined)
+        template = env.from_string(template_str)
+        return template.render(**context)
+
+    @staticmethod
+    def render_file(template_path: str, context: Optional[dict] = None) -> str:
+        """渲染模板文件
+
+        :param template_path: 模板文件路径
+        :param context: 上下文变量字典
+        :return: 渲染后的字符串
+        """
+        if context is None:
+            context = {}
+        template_path = os.path.abspath(template_path)
+        template_dir = os.path.dirname(template_path)
+        template_name = os.path.basename(template_path)
+        env = Environment(loader=FileSystemLoader(template_dir), undefined=StrictUndefined)
+        template = env.get_template(template_name)
+        return template.render(**context)

hutool/http/__init__.py

@@ -0,0 +1,6 @@
+from .html_util import HtmlUtil
+from .http_request import HttpRequest
+from .http_response import HttpResponse
+from .http_util import HttpUtil
+
+__all__ = ["HtmlUtil", "HttpRequest", "HttpResponse", "HttpUtil"]

hutool/http/html_util.py

@@ -0,0 +1,88 @@
+import html
+import re
+
+
+class HtmlUtil:
+    """HTML工具类，提供HTML相关的常用处理方法"""
+
+    # 需要被替换的HTML空白字符（制表符、换行符、回车符）
+    _EMPTY_REGEX = re.compile(r"[\t\n\r]")
+
+    @staticmethod
+    def escape(html_str: str) -> str:
+        """HTML转义
+
+        将特殊字符转换为HTML实体，防止XSS攻击。
+        转义规则: & -> &amp; < -> &lt; > -> &gt; " -> &quot; ' -> &#x27;
+
+        :param html_str: 待转义的HTML字符串
+        :return: 转义后的安全字符串
+        """
+        if html_str is None:
+            return ""
+        return html.escape(html_str, quote=True)
+
+    @staticmethod
+    def unescape(html_str: str) -> str:
+        """HTML反转义
+
+        将HTML实体转换回原始字符。
+
+        :param html_str: 待反转义的HTML字符串
+        :return: 反转义后的原始字符串
+        """
+        if html_str is None:
+            return ""
+        return html.unescape(html_str)
+
+    @staticmethod
+    def remove_html_tag(html_str: str) -> str:
+        """移除HTML标签
+
+        移除字符串中的所有HTML标签，只保留纯文本内容。
+
+        :param html_str: 包含HTML标签的字符串
+        :return: 移除标签后的纯文本
+        """
+        if html_str is None:
+            return ""
+        # 移除HTML注释
+        text = re.sub(r"<!--.*?-->", "", html_str, flags=re.DOTALL)
+        # 移除script和style标签及其内容
+        text = re.sub(r"<script[^>]*>.*?</script>", "", text, flags=re.DOTALL | re.IGNORECASE)
+        text = re.sub(r"<style[^>]*>.*?</style>", "", text, flags=re.DOTALL | re.IGNORECASE)
+        # 移除所有HTML标签
+        text = re.sub(r"<[^>]+>", "", text)
+        # 清理多余空白
+        text = HtmlUtil._EMPTY_REGEX.sub(" ", text)
+        text = re.sub(r"\s+", " ", text)
+        return text.strip()
+
+    @staticmethod
+    def clean_html_tag(html_str: str) -> str:
+        """清理HTML标签
+
+        移除字符串中的所有HTML标签，只保留纯文本内容。
+        本方法与 remove_html_tag 功能相同。
+
+        :param html_str: 包含HTML标签的字符串
+        :return: 清理标签后的纯文本
+        """
+        return HtmlUtil.remove_html_tag(html_str)
+
+    @staticmethod
+    def wrap_html(text: str) -> str:
+        """包装为HTML段落
+
+        将文本中的换行符转换为HTML的 <br> 标签，并用 <p> 标签包装。
+
+        :param text: 纯文本字符串
+        :return: 包装后的HTML段落字符串
+        """
+        if text is None:
+            return ""
+        # 转义HTML特殊字符
+        escaped = html.escape(text, quote=False)
+        # 将换行符替换为 <br> 标签
+        escaped = escaped.replace("\n", "<br>")
+        return f"<p>{escaped}</p>"

hutool/http/http_request.py

@@ -0,0 +1,188 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+
+class HttpRequest:
+    """HTTP请求对象，支持链式调用
+
+    示例::
+
+        response = (HttpRequest.get("https://example.com")
+            .header("Accept", "application/json")
+            .timeout(5000)
+            .execute())
+    """
+
+    def __init__(self, url: str, method: str = "GET"):
+        """构造HTTP请求
+
+        :param url: 请求URL
+        :param method: HTTP方法，默认GET
+        """
+        self._url: str = url
+        self._method: str = method.upper()
+        self._headers: Dict[str, str] = {}
+        self._cookies: Dict[str, str] = {}
+        self._form: Dict[str, str] = {}
+        self._body: Optional[str] = None
+        self._json_data: Any = None
+        self._timeout: int = 30000  # 毫秒
+        self._charset: str = "utf-8"
+        self._follow_redirects: bool = True
+        self._params: Optional[Dict[str, str]] = None
+
+    @classmethod
+    def get(cls, url: str) -> "HttpRequest":
+        """创建GET请求
+
+        :param url: 请求URL
+        :return: HttpRequest实例
+        """
+        return cls(url, "GET")
+
+    @classmethod
+    def post(cls, url: str) -> "HttpRequest":
+        """创建POST请求
+
+        :param url: 请求URL
+        :return: HttpRequest实例
+        """
+        return cls(url, "POST")
+
+    def method(self, method: str) -> "HttpRequest":
+        """设置HTTP方法
+
+        :param method: HTTP方法名，如GET、POST、PUT、DELETE等
+        :return: 当前实例，支持链式调用
+        """
+        self._method = method.upper()
+        return self
+
+    def header(self, name: str, value: str) -> "HttpRequest":
+        """设置单个请求头
+
+        :param name: 请求头名称
+        :param value: 请求头值
+        :return: 当前实例，支持链式调用
+        """
+        self._headers[name] = value
+        return self
+
+    def headers(self, headers: dict) -> "HttpRequest":
+        """批量设置请求头
+
+        :param headers: 请求头字典
+        :return: 当前实例，支持链式调用
+        """
+        self._headers.update(headers)
+        return self
+
+    def cookie(self, cookie: str) -> "HttpRequest":
+        """设置Cookie
+
+        支持格式: "name=value" 或 "name1=value1; name2=value2"
+
+        :param cookie: Cookie字符串
+        :return: 当前实例，支持链式调用
+        """
+        if not cookie:
+            return self
+        for item in cookie.split(";"):
+            item = item.strip()
+            if "=" in item:
+                key, value = item.split("=", 1)
+                self._cookies[key.strip()] = value.strip()
+        return self
+
+    def form(self, key: str, value: Optional[str] = None) -> "HttpRequest":
+        """添加表单参数
+
+        :param key: 参数名
+        :param value: 参数值
+        :return: 当前实例，支持链式调用
+        """
+        if value is not None:
+            self._form[key] = value
+        return self
+
+    def body(self, body: str) -> "HttpRequest":
+        """设置请求体
+
+        :param body: 请求体字符串
+        :return: 当前实例，支持链式调用
+        """
+        self._body = body
+        return self
+
+    def json(self, json_data: Any) -> "HttpRequest":
+        """设置JSON请求体
+
+        :param json_data: JSON可序列化的数据
+        :return: 当前实例，支持链式调用
+        """
+        self._json_data = json_data
+        return self
+
+    def timeout(self, timeout: int) -> "HttpRequest":
+        """设置超时时间（毫秒）
+
+        :param timeout: 超时时间，单位毫秒
+        :return: 当前实例，支持链式调用
+        """
+        self._timeout = timeout
+        return self
+
+    def charset(self, charset: str) -> "HttpRequest":
+        """设置字符集
+
+        :param charset: 字符集名称，如 utf-8、gbk 等
+        :return: 当前实例，支持链式调用
+        """
+        self._charset = charset
+        return self
+
+    def follow_redirects(self, is_follow: bool) -> "HttpRequest":
+        """设置是否跟随重定向
+
+        :param is_follow: 是否跟随重定向
+        :return: 当前实例，支持链式调用
+        """
+        self._follow_redirects = is_follow
+        return self
+
+    def execute(self) -> "HttpResponse":  # noqa: F821
+        """执行HTTP请求
+
+        :return: HttpResponse响应对象
+        :raises httpx.HTTPStatusError: 当响应状态码表示错误时
+        :raises httpx.RequestError: 当请求发生网络错误时
+        """
+        # 导入放在此处避免循环导入
+        from .http_response import HttpResponse
+
+        timeout_seconds = self._timeout / 1000.0
+
+        kwargs: Dict[str, Any] = {
+            "method": self._method,
+            "url": self._url,
+            "headers": self._headers,
+            "cookies": self._cookies,
+            "timeout": timeout_seconds,
+            "follow_redirects": self._follow_redirects,
+        }
+
+        if self._params:
+            kwargs["params"] = self._params
+
+        if self._json_data is not None:
+            kwargs["json"] = self._json_data
+        elif self._body is not None:
+            kwargs["content"] = self._body.encode(self._charset)
+        elif self._form:
+            kwargs["data"] = self._form
+
+        with httpx.Client() as client:
+            response = client.request(**kwargs)
+
+        return HttpResponse(response, charset=self._charset)

hutool/http/http_response.py

@@ -0,0 +1,139 @@
+from typing import Any, Dict, Optional
+
+import httpx
+
+
+class HttpResponse:
+    """HTTP响应对象
+
+    封装httpx.Response，提供便捷的响应数据访问方法。
+    """
+
+    def __init__(self, response: httpx.Response, charset: str = "utf-8"):
+        """构造HTTP响应
+
+        :param response: httpx响应对象
+        :param charset: 字符集，默认utf-8
+        """
+        self._response: httpx.Response = response
+        self._charset: str = charset
+
+    @property
+    def status(self) -> int:
+        """获取HTTP状态码
+
+        :return: HTTP状态码，如200、404等
+        """
+        return self._response.status_code
+
+    @property
+    def headers(self) -> Dict[str, str]:
+        """获取响应头
+
+        :return: 响应头字典
+        """
+        return dict(self._response.headers)
+
+    @property
+    def body(self) -> str:
+        """获取响应体字符串
+
+        :return: 响应体字符串
+        """
+        return self._response.text
+
+    @property
+    def content_length(self) -> int:
+        """获取响应体长度
+
+        :return: 响应体字节长度
+        """
+        content_length = self._response.headers.get("content-length")
+        if content_length is not None:
+            return int(content_length)
+        return len(self._response.content)
+
+    @property
+    def charset(self) -> str:
+        """获取字符集
+
+        :return: 字符集名称
+        """
+        return self._charset
+
+    @property
+    def content_type(self) -> str:
+        """获取Content-Type
+
+        :return: Content-Type头值
+        """
+        return self._response.headers.get("content-type", "")
+
+    @property
+    def url(self) -> str:
+        """获取最终响应的URL（考虑重定向）
+
+        :return: 响应的URL字符串
+        """
+        return str(self._response.url)
+
+    def is_ok(self) -> bool:
+        """判断状态码是否为2xx（成功）
+
+        :return: 状态码在200-299范围内返回True
+        """
+        return 200 <= self.status < 300
+
+    def to_bytes(self) -> bytes:
+        """获取响应体的字节数组
+
+        :return: 响应体字节数组
+        """
+        return self._response.content
+
+    def to_json(self) -> Any:
+        """将响应体解析为JSON
+
+        :return: 解析后的JSON对象（dict或list）
+        :raises json.JSONDecodeError: 响应体不是有效JSON时抛出
+        """
+        return self._response.json()
+
+    def to_str(self) -> str:
+        """获取响应体字符串
+
+        使用指定的字符集解码响应体。
+
+        :return: 响应体字符串
+        """
+        return self._response.text
+
+    def header(self, name: str) -> Optional[str]:
+        """获取指定名称的响应头
+
+        :param name: 响应头名称
+        :return: 响应头值，不存在时返回None
+        """
+        return self._response.headers.get(name)
+
+    def cookie(self, name: str) -> Optional[str]:
+        """获取指定名称的Cookie值
+
+        :param name: Cookie名称
+        :return: Cookie值，不存在时返回None
+        """
+        return self._response.cookies.get(name)
+
+    def __str__(self) -> str:
+        """返回响应的字符串表示
+
+        :return: 包含状态码和URL的字符串
+        """
+        return f"HttpResponse [status={self.status}, url={self.url}]"
+
+    def __repr__(self) -> str:
+        """返回响应的详细表示
+
+        :return: 包含状态码和URL的字符串
+        """
+        return self.__str__()