lesscode-flask 0.2.115__tar.gz → 0.2.117__tar.gz

{lesscode_flask-0.2.115 → lesscode_flask-0.2.117}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lesscode-flask
-Version: 0.2.115
+Version: 0.2.117
 Summary: lesscode-flask 是基于flask的web开发脚手架项目，该项目初衷为简化开发过程，让研发人员更加关注业务。
 Home-page: https://lesscode-flask
 Author: Chao.yy

{lesscode_flask-0.2.115 → lesscode_flask-0.2.117}/lesscode_flask/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.2.115"
+__version__ = "0.2.117"
 
 import functools
 import logging

{lesscode_flask-0.2.115 → lesscode_flask-0.2.117}/lesscode_flask/setting/__init__.py

@@ -100,7 +100,7 @@ class BaseConfig:
     SIGN_NONCE_ENABLE: bool = True
     # nonce缓存时长（秒）
     SIGN_NONCE_TTL_SEC: int = 300
-    # 签名白名单路径前缀
+    # 签名白名单路径，普通配置按前缀匹配；带 * 时支持任意内容通配，例如 /a/*/b
     SIGN_WHITE_LIST: list = [SWAGGER_URL, SWAGGER_API_URL, f"{ROUTE_PREFIX}/oauth/token", f"{ROUTE_PREFIX}/oauth/captcha"]
     # 签名IP白名单（支持单IP或CIDR，命中后跳过签名校验）
     SIGN_IP_WHITE_LIST: list = []

lesscode_flask-0.2.117/lesscode_flask/utils/oss/__init__.py

@@ -0,0 +1,352 @@
+import copy
+import os
+from io import BytesIO
+
+from lesscode_flask.utils.helpers import app_config
+from lesscode_flask.utils.oss.aliyun_oss import AliYunOss
+from lesscode_flask.utils.oss.ks3_oss import Ks3Oss
+from lesscode_flask.utils.oss.minio_oss import MinioOss
+from lesscode_flask.utils.oss.rustfs_oss import RustfsOss
+
+
+class CommonOss:
+    def __init__(self, storage_type=None, data_type="stream", config_key="default", **kwargs):
+        """
+        初始化统一 OSS 入口。
+
+        Args:
+            storage_type (str): 存储类型，可选值：
+                - "ks3"     : 金山云 KS3 对象存储，依赖 ks3sdk==1.5.0
+                - "aliyun"  : 阿里云 OSS，依赖 oss2
+                - "minio"   : MinIO / 自托管 S3，依赖 minio
+                - "rustfs"  : RustFS（S3 兼容），依赖 boto3
+                - "file"    : 本地文件系统存储，无额外依赖
+            data_type (str): 数据来源类型，可选值：
+                - "stream"    : 从文件流（BytesIO / werkzeug FileStorage）上传（默认）
+                - "file_path" : 从本地文件路径上传
+            config_key (str): 读取 app.config["STORAGE_CONFIG"] 时使用的配置键名，默认 "default"。
+                STORAGE_CONFIG 示例结构：
+                    STORAGE_CONFIG = {
+                        "default": {
+                            "storage_type": "<storage_type>",
+                            "storage_config": { ...各存储类型连接参数... }
+                        }
+                    }
+            **kwargs:
+                storage_config (dict): 直接传入连接参数字典，会覆盖 STORAGE_CONFIG 中的 storage_config。
+                bucket_name    (str) : 直接指定桶名，会覆盖 STORAGE_CONFIG 中的 bucket_name。
+
+        各存储类型的 storage_config 参数说明
+        =====================================
+
+        ── ks3（金山云 KS3）──────────────────────────────────────────
+            依赖：pip install ks3sdk==1.5.0
+            storage_config 字段：
+                access_key_id     (str, 必填) : KS3 Access Key ID
+                access_key_secret (str, 必填) : KS3 Access Key Secret
+                host              (str, 必填) : KS3 服务域名，例如 "ks3-cn-beijing.ksyun.com"
+                is_secure         (bool, 可选): 是否启用 HTTPS，默认 False
+                bucket_name       (str, 必填) : 默认操作的桶名
+            STORAGE_CONFIG 示例：
+                "storage_config": {
+                    "access_key_id": "your-access-key-id",
+                    "access_key_secret": "your-access-key-secret",
+                    "host": "ks3-cn-beijing.ksyun.com",
+                    "is_secure": False,
+                    "bucket_name": "your-bucket"
+                }
+            save() 返回的 URL 格式：
+                https://<bucket_name>.<region>.ksyun.com/<key>
+                region 默认 "ks3-cn-beijing"，domain 默认 "ksyun.com"
+
+        ── aliyun（阿里云 OSS）──────────────────────────────────────
+            依赖：pip install oss2
+            storage_config 字段：
+                access_key_id     (str, 必填) : 阿里云 Access Key ID
+                access_key_secret (str, 必填) : 阿里云 Access Key Secret
+                endpoint          (str, 必填) : OSS Endpoint，例如 "https://oss-cn-hangzhou.aliyuncs.com"
+                bucket_name       (str, 必填) : 默认操作的桶名
+                region            (str, 可选) : 地域标识，默认 "oss-cn-hangzhou"，用于拼接公网 URL
+                domain            (str, 可选) : 域名后缀，默认 "aliyuncs.com"
+                protocol          (str, 可选) : URL 协议，默认 "https"
+                session           (obj, 可选) : oss2 Session 对象
+                connect_timeout   (int, 可选) : 连接超时秒数
+                proxies           (dict, 可选): 代理配置
+                cloudbox_id       (str, 可选) : 云盒 ID（云盒场景使用）
+                is_path_style     (bool, 可选): 是否使用 Path-Style 访问，默认 False
+            STORAGE_CONFIG 示例：
+                "storage_config": {
+                    "access_key_id": "your-access-key-id",
+                    "access_key_secret": "your-access-key-secret",
+                    "endpoint": "https://oss-cn-hangzhou.aliyuncs.com",
+                    "bucket_name": "your-bucket",
+                    "region": "oss-cn-hangzhou"
+                }
+            save() 返回的 URL 格式：
+                https://<bucket_name>.<region>.aliyuncs.com/<key>
+
+        ── minio（MinIO / 自托管 S3 兼容）──────────────────────────
+            依赖：pip install minio
+            storage_config 字段：
+                service     (str, 必填) : MinIO 服务地址（不含协议），例如 "127.0.0.1:9000"
+                access_key  (str, 必填) : MinIO Access Key（用户名）
+                secret_key  (str, 必填) : MinIO Secret Key（密码）
+                secure      (bool, 可选): 是否启用 HTTPS，默认 False
+                bucket_name (str, 必填) : 默认操作的桶名
+            STORAGE_CONFIG 示例：
+                "storage_config": {
+                    "service": "127.0.0.1:9000",
+                    "access_key": "minioadmin",
+                    "secret_key": "minioadmin",
+                    "secure": False,
+                    "bucket_name": "your-bucket"
+                }
+            save() 返回的 URL 格式：
+                presigned_get_object 生成的预签名 URL（有效期 3600 秒）
+
+        ── rustfs（RustFS，S3 兼容协议）─────────────────────────────
+            依赖：pip install boto3
+            storage_config 字段：
+                endpoint    (str, 必填) : RustFS 服务地址，可含协议头，
+                                          例如 "http://127.0.0.1:9000" 或 "127.0.0.1:9000"
+                access_key  (str, 必填) : Access Key ID
+                secret_key  (str, 必填) : Secret Access Key
+                secure      (bool, 可选): 为 True 时自动补全 "https://"，默认 False（即 "http://"）；
+                                          若 endpoint 已含协议头则忽略此参数
+                region      (str, 可选) : S3 Region，默认 "us-east-1"（RustFS 通常不校验）
+                bucket_name (str, 必填) : 默认操作的桶名
+            STORAGE_CONFIG 示例：
+                "storage_config": {
+                    "endpoint": "http://127.0.0.1:9000",
+                    "access_key": "rustfsadmin",
+                    "secret_key": "rustfsadmin",
+                    "secure": False,
+                    "region": "us-east-1",
+                    "bucket_name": "your-bucket"
+                }
+            save() 返回的 URL 格式：
+                <endpoint_url>/<bucket_name>/<key>
+                例如：http://127.0.0.1:9000/your-bucket/path/to/file.jpg
+
+        ── file（本地文件系统）──────────────────────────────────────
+            无额外依赖
+            storage_config 字段：
+                STORAGE_DIR (str, 必填) : 本地存储根目录的绝对路径，
+                                          例如 "/data/uploads"
+                bucket_name 不适用，文件直接按 key 的路径层级写入 STORAGE_DIR
+            STORAGE_CONFIG 示例：
+                "storage_config": {
+                    "STORAGE_DIR": "/data/uploads"
+                }
+            save() 返回的 URL 格式：
+                文件在磁盘上的完整绝对路径，例如 "/data/uploads/2024/01/photo.jpg"
+            注意：
+                - key 中的路径分隔符（"/" 或 "\\"）会被转换为系统路径，目录不存在时自动创建
+                - data_type="file_path" 时会先读取源文件再写入目标路径
+        """
+        storage_config_setting = app_config.get("STORAGE_CONFIG", {})
+        storage_config = copy.deepcopy(storage_config_setting) or dict()
+        _storage_config = storage_config.get(config_key, {}) or dict()
+        _storage_config_storage_type = _storage_config.get("storage_type", "")
+        _storage_type = storage_type if storage_type else _storage_config_storage_type
+        _config_storage_config = _storage_config.get("storage_config", {})
+        _config_bucket_name = _config_storage_config.pop("bucket_name", "")
+        self.storage_type = _storage_type
+        self.data_type = data_type
+        self.storage_config = kwargs.get("storage_config", {}) if kwargs.get("storage_config",
+                                                                             {}) else _config_storage_config
+        self.bucket_name = kwargs.get("bucket_name") or _config_bucket_name
+
+    def _save(self, key, io_stream: BytesIO = None, file_path: str = None, bucket_name: str = None):
+        file_url_obj = dict()
+        if self.storage_type == "ks3":
+            if self.data_type == "stream":
+                storage_config = self.storage_config or dict()
+                ks3 = Ks3Oss(bucket_name=bucket_name or self.bucket_name, **storage_config)
+                url = ks3.save(key=key, string_data=io_stream.getvalue(), content_type="string", policy="public-read",
+                               bucket_name=bucket_name or self.bucket_name)
+                file_url_obj = {"key": key, "url": url}
+            elif self.data_type == "file_path":
+                storage_config = self.storage_config or dict()
+                ks3 = Ks3Oss(bucket_name=bucket_name or self.bucket_name, **storage_config)
+                url = ks3.save(key=key, filename=file_path, content_type="filename", policy="public-read")
+                file_url_obj = {"key": key, "url": url}
+        elif self.storage_type == "aliyun":
+            storage_config = self.storage_config or dict()
+            aliyun = AliYunOss(bucket_name=bucket_name or self.bucket_name, **storage_config)
+            url = aliyun.save(key=key, content_type="string", data=io_stream.getvalue(),
+                              bucket_name=bucket_name or self.bucket_name)
+            file_url_obj = {"key": key, "url": url}
+        elif self.storage_type == "minio":
+            storage_config = self.storage_config or dict()
+            minio = MinioOss(**storage_config)
+            url = minio.save(key=key, content_type="string", data=io_stream.getvalue(),
+                             bucket_name=bucket_name or self.bucket_name)
+            file_url_obj = {"key": key, "url": url}
+        elif self.storage_type == "rustfs":
+            storage_config = self.storage_config or dict()
+            rustfs = RustfsOss(**storage_config)
+            url = rustfs.save(key=key, content_type="string", data=io_stream.getvalue(),
+                              bucket_name=bucket_name or self.bucket_name)
+            file_url_obj = {"key": key, "url": url}
+        elif self.storage_type == "file":
+            storage_path = ""
+            storage_dir = self.storage_config.get("STORAGE_DIR", "")
+            if not storage_dir:
+                raise Exception("storage_dir is empty")
+            if self.data_type == "stream":
+                if "\\" in key:
+                    key_list = key.split("\\")
+                elif "/" in key:
+                    key_list = key.split("/")
+                else:
+                    key_list = [key]
+                storage_path = storage_dir
+                if key_list:
+                    for k in key_list:
+                        storage_path = os.path.join(storage_path, k)
+                dir_path = os.path.dirname(storage_path)
+                if not os.path.exists(dir_path):
+                    os.makedirs(dir_path)
+            elif self.data_type == "file_path":
+                with open(file_path, 'rb') as infile:
+                    io_stream = BytesIO(infile.read())
+            if storage_path:
+                with open(storage_path, 'wb') as outfile:
+                    outfile.write(io_stream.getvalue())
+                file_url_obj = {"key": key, "url": storage_path}
+        return file_url_obj
+
+    def upload(self, **kwargs):
+        """上传文件到对象存储。
+
+        Args:
+            files (list, 必填): 待上传的文件列表。根据 data_type 不同，列表元素格式不同：
+
+                data_type="stream" 时，每个元素可以是：
+                    - werkzeug FileStorage 对象（Flask request.files 中的文件）
+                      内部会读取 f.filename 作为 key，f.stream.read() 作为内容
+                    - dict，格式：
+                        {
+                            "key":    str,                    # 对象存储中的文件路径/名称，例如 "images/2024/photo.jpg"
+                         "stream": werkzeug.FileStorage    # 文件流对象
+                        }
+
+                data_type="file_path" 时，每个元素可以是：
+                    - str，本地文件的绝对路径，例如 "/tmp/photo.jpg"
+                      key 自动取路径中的文件名部分
+                    - dict，格式：
+                        {
+                            "key":       str,   # 对象存储中的文件路径/名称
+                            "file_path": str    # 本地文件的绝对路径
+                        }
+
+            bucket_name (str, 可选): 上传到的目标桶名，默认使用初始化时指定的 bucket_name。
+
+        Returns:
+            list[dict]: 每个元素对应一个上传结果，格式为：
+                {
+                    "key": str,   # 上传时使用的对象 key
+                    "url": str    # 文件的访问地址：
+                                  #   ks3    → https://<bucket>.<region>.ksyun.com/<key>
+                                  #   aliyun → https://<bucket>.<region>.aliyuncs.com/<key>
+                                  #   minio  → presigned URL（有效期 3600 秒）
+                                  #   rustfs → http(s)://<endpoint>/<bucket>/<key>
+                                  #   file   → 本地文件绝对路径
+                }
+
+        Raises:
+            Exception: files 为空时抛出 "files is empty"
+        """
+        file_url_list = []
+        files = kwargs.get("files", [])
+        bucket_name = kwargs.get("bucket_name", self.bucket_name)
+        if not files:
+            raise Exception("files is empty")
+        if self.data_type == "stream":
+            for f in files:
+                if not isinstance(f, dict):
+                    key = f.filename
+                    stream = f.stream.read()
+                    file_stream = BytesIO(stream)
+                else:
+                    key = f.get("key", "")
+                    _steam = f.get("stream")
+                    stream = _steam.stream.read()
+                    file_stream = BytesIO(stream)
+                file_url_obj = self._save(key=key, io_stream=file_stream, bucket_name=bucket_name)
+                file_url_list.append(file_url_obj)
+
+        elif self.data_type == "file_path":
+            for f in files:
+                if not isinstance(f, dict):
+                    if "\\" in f:
+                        file_name = f.split("\\")[-1]
+                    elif "/" in f:
+                        file_name = f.split("/")[-1]
+                    else:
+                        file_name = f
+                    key = file_name
+                    _file_path = f
+                else:
+                    key = f.get("key", "")
+                    _file_path = f.get("file_path")
+                file_url_obj = self._save(key=key, file_path=_file_path, bucket_name=bucket_name)
+                file_url_list.append(file_url_obj)
+        return file_url_list
+
+    def download(self, key, bucket_name=None):
+        """从对象存储下载文件，返回文件内容。
+
+        Args:
+            key (str, 必填): 文件在对象存储中的 key（即上传时使用的路径/名称），
+                             例如 "images/2024/photo.jpg"。
+                             对于 storage_type="file"，key 同样支持 "/" 或 "\\" 分隔的相对路径，
+                             会与 STORAGE_DIR 拼接成完整本地路径。
+            bucket_name (str, 可选): 目标桶名，默认使用初始化时指定的 bucket_name。
+
+        Returns:
+            各存储类型返回值说明：
+                - ks3    : bytes，文件的原始字节内容
+                - aliyun : oss2 GetObjectResult 对象，支持 .read() 读取内容，
+                           也可通过 get_file(file_path=...) 直接保存到本地
+                - minio  : urllib3 HTTPResponse 对象，支持 .read() 或迭代流式读取，
+                           使用后需调用 .close() 释放连接
+                - rustfs : botocore StreamingBody 对象，支持 .read() 或 .iter_chunks() 流式读取
+                - file   : bytes，从本地文件读取的原始字节内容
+            若 storage_type 未匹配任何已知类型，返回 None。
+
+        Raises:
+            FileNotFoundError: storage_type="file" 时，若本地文件不存在则抛出
+        """
+        if self.storage_type == "ks3":
+            storage_config = self.storage_config or dict()
+            ks3 = Ks3Oss(bucket_name=self.bucket_name, **storage_config)
+            return ks3.get_file(key=key, bucket_name=bucket_name or self.bucket_name)
+        elif self.storage_type == "aliyun":
+            storage_config = self.storage_config or dict()
+            aliyun = AliYunOss(bucket_name=self.bucket_name, **storage_config)
+            return aliyun.get_file(key=key, bucket_name=bucket_name or self.bucket_name)
+        elif self.storage_type == "minio":
+            storage_config = self.storage_config or dict()
+            minio = MinioOss(**storage_config)
+            return minio.get_file(bucket_name=bucket_name or self.bucket_name, key=key)
+        elif self.storage_type == "rustfs":
+            storage_config = self.storage_config or dict()
+            rustfs = RustfsOss(**storage_config)
+            return rustfs.get_file(bucket_name=bucket_name or self.bucket_name, key=key)
+        if self.storage_type == "file":
+            storage_dir = self.storage_config.get("STORAGE_DIR", "")
+            if "\\" in key:
+                key_list = key.split("\\")
+            elif "/" in key:
+                key_list = key.split("/")
+            else:
+                key_list = [key]
+            file_path = storage_dir
+            if key_list:
+                for k in key_list:
+                    file_path = os.path.join(file_path, k)
+            with open(file_path, 'rb') as f:
+                return f.read()
+        return None

lesscode_flask-0.2.117/lesscode_flask/utils/oss/rustfs_oss.py

@@ -0,0 +1,170 @@
+import importlib
+import logging
+from datetime import timedelta
+from io import BytesIO
+
+
+class RustfsOss:
+    """
+    RustFS 对象存储客户端（基于 S3 兼容协议，使用 boto3）
+    RustFS is an S3-compatible object storage written in Rust.
+    """
+
+    def __init__(self, endpoint, access_key, secret_key, secure=False, region="us-east-1"):
+        try:
+            boto3 = importlib.import_module("boto3")
+        except ImportError:
+            raise Exception("boto3 is not installed, run: pip install boto3")
+
+        protocol = "https" if secure else "http"
+        endpoint_url = endpoint if endpoint.startswith("http") else f"{protocol}://{endpoint}"
+
+        self.endpoint_url = endpoint_url
+        self.region = region
+        self.client = boto3.client(
+            "s3",
+            endpoint_url=endpoint_url,
+            aws_access_key_id=access_key,
+            aws_secret_access_key=secret_key,
+            region_name=region,
+        )
+
+    # ------------------------------------------------------------------
+    # Bucket operations
+    # ------------------------------------------------------------------
+
+    def exists_bucket(self, bucket_name: str) -> bool:
+        """判断桶是否存在"""
+        try:
+            self.client.head_bucket(Bucket=bucket_name)
+            return True
+        except Exception:
+            return False
+
+    def create_bucket(self, bucket_name: str, public_read: bool = True) -> bool:
+        """创建桶，可选设置公共读策略"""
+        if self.exists_bucket(bucket_name):
+            return False
+        self.client.create_bucket(Bucket=bucket_name)
+        if public_read:
+            import json
+            policy = json.dumps({
+                "Version": "2012-10-17",
+                "Statement": [
+                    {
+                        "Effect": "Allow",
+                        "Principal": {"AWS": ["*"]},
+                        "Action": ["s3:GetObject"],
+                        "Resource": [f"arn:aws:s3:::{bucket_name}/*"],
+                    }
+                ],
+            })
+            self.client.put_bucket_policy(Bucket=bucket_name, Policy=policy)
+        return True
+
+    def get_bucket_list(self) -> list:
+        """列出所有桶"""
+        resp = self.client.list_buckets()
+        return [
+            {"bucket_name": b["Name"], "create_time": b.get("CreationDate")}
+            for b in resp.get("Buckets", [])
+        ]
+
+    def remove_bucket(self, bucket_name: str) -> bool:
+        """删除桶（桶需为空）"""
+        try:
+            self.client.delete_bucket(Bucket=bucket_name)
+            return True
+        except Exception as e:
+            logging.error(f"[RustfsOss] remove_bucket error: {e}")
+            return False
+
+    # ------------------------------------------------------------------
+    # Object operations
+    # ------------------------------------------------------------------
+
+    def bucket_list_files(self, bucket_name: str, prefix: str = "") -> list:
+        """列出桶内所有对象"""
+        try:
+            paginator = self.client.get_paginator("list_objects_v2")
+            files = []
+            for page in paginator.paginate(Bucket=bucket_name, Prefix=prefix):
+                for obj in page.get("Contents", []):
+                    files.append(obj)
+            return files
+        except Exception as e:
+            logging.error(f"[RustfsOss] bucket_list_files error: {e}")
+            return []
+
+    def save(self, key: str, bucket_name: str, data, content_type: str = "string", **kwargs) -> str:
+        """
+        上传对象并返回访问 URL
+        :param key:          对象名（含路径）
+        :param bucket_name:  桶名
+        :param data:         bytes（content_type="string"）或本地文件路径（content_type="filename"）
+        :param content_type: "string" | "filename"
+        :return:             公共访问 URL
+        """
+        if content_type == "filename":
+            with open(data, "rb") as f:
+                data = f.read()
+
+        if isinstance(data, str):
+            data = data.encode("utf-8")
+
+        self.client.put_object(
+            Bucket=bucket_name,
+            Key=key,
+            Body=BytesIO(data),
+            **kwargs,
+        )
+        return f"{self.endpoint_url}/{bucket_name}/{key}"
+
+    def get_file(self, bucket_name: str, key: str):
+        """下载对象，返回响应对象（含 .read() 方法）"""
+        resp = self.client.get_object(Bucket=bucket_name, Key=key)
+        return resp["Body"]
+
+    def download_file(self, bucket_name: str, key: str, file_path: str):
+        """下载对象并保存到本地文件"""
+        self.client.download_file(Bucket=bucket_name, Key=key, Filename=file_path)
+
+    def upload_file(self, bucket_name: str, key: str, file_path: str, content_type: str = "application/octet-stream"):
+        """从本地文件上传对象"""
+        with open(file_path, "rb") as f:
+            self.client.put_object(
+                Bucket=bucket_name,
+                Key=key,
+                Body=f,
+                ContentType=content_type,
+            )
+
+    def remove_file(self, bucket_name: str, key: str):
+        """删除单个对象"""
+        self.client.delete_object(Bucket=bucket_name, Key=key)
+
+    def remove_files(self, bucket_name: str, key_list: list):
+        """批量删除对象"""
+        objects = [{"Key": k} for k in key_list]
+        self.client.delete_objects(Bucket=bucket_name, Delete={"Objects": objects})
+
+    def stat_object(self, bucket_name: str, key: str):
+        """获取对象元数据"""
+        try:
+            return self.client.head_object(Bucket=bucket_name, Key=key)
+        except Exception as e:
+            logging.error(f"[RustfsOss] stat_object error: {e}")
+            return None
+
+    def copy_file(self, src_bucket: str, src_key: str, dst_bucket: str, dst_key: str):
+        """复制对象"""
+        copy_source = {"Bucket": src_bucket, "Key": src_key}
+        self.client.copy_object(CopySource=copy_source, Bucket=dst_bucket, Key=dst_key)
+
+    def presigned_get_file(self, bucket_name: str, key: str, days: int = 7) -> str:
+        """生成预签名 GET URL"""
+        return self.client.generate_presigned_url(
+            "get_object",
+            Params={"Bucket": bucket_name, "Key": key},
+            ExpiresIn=int(timedelta(days=days).total_seconds()),
+        )

{lesscode_flask-0.2.115 → lesscode_flask-0.2.117}/lesscode_flask/utils/sign/signature.py

@@ -2,6 +2,7 @@ import hashlib
 import hmac
 import ipaddress
 import logging
+import re
 import time
 
 from flask import request
@@ -70,13 +71,23 @@ def _canonical_sign_content(timestamp: str, nonce: str) -> str:
     return f"{method}\n{path}\n{query_string}\n{body_hash}\n{timestamp}\n{nonce}"
 
 
+def _match_sign_white_path(request_path: str, white_item: str) -> bool:
+    white_path = (white_item or "").strip()
+    if not white_path:
+        return False
+    if "*" not in white_path:
+        return request_path.startswith(white_path)
+    pattern = re.escape(white_path).replace(r"\*", ".*")
+    return re.match(f"^{pattern}", request_path) is not None
+
+
 def _in_sign_white_list(white_list: list) -> bool:
-    # 白名单匹配规则：只要请求路径以前缀命中就跳过签名校验。
+    # 白名单匹配规则：普通配置按前缀匹配；带 * 时支持任意内容通配。
     if not white_list:
         return False
     request_path = request.path or ""
     for white_item in white_list:
-        if white_item and request_path.startswith(white_item):
+        if _match_sign_white_path(request_path, white_item):
             return True
     return False
 

{lesscode_flask-0.2.115 → lesscode_flask-0.2.117}/lesscode_flask.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lesscode-flask
-Version: 0.2.115
+Version: 0.2.117
 Summary: lesscode-flask 是基于flask的web开发脚手架项目，该项目初衷为简化开发过程，让研发人员更加关注业务。
 Home-page: https://lesscode-flask
 Author: Chao.yy

{lesscode_flask-0.2.115 → lesscode_flask-0.2.117}/lesscode_flask.egg-info/SOURCES.txt

@@ -51,6 +51,7 @@ lesscode_flask/utils/oss/__init__.py
 lesscode_flask/utils/oss/aliyun_oss.py
 lesscode_flask/utils/oss/ks3_oss.py
 lesscode_flask/utils/oss/minio_oss.py
+lesscode_flask/utils/oss/rustfs_oss.py
 lesscode_flask/utils/redis/redis_helper.py
 lesscode_flask/utils/request/request.py
 lesscode_flask/utils/sign/__init__.py

lesscode_flask-0.2.115/lesscode_flask/utils/oss/__init__.py

@@ -1,165 +0,0 @@
-import copy
-import os
-from io import BytesIO
-
-from lesscode_flask.utils.helpers import app_config
-from lesscode_flask.utils.oss.aliyun_oss import AliYunOss
-from lesscode_flask.utils.oss.ks3_oss import Ks3Oss
-from lesscode_flask.utils.oss.minio_oss import MinioOss
-
-
-class CommonOss:
-    def __init__(self, storage_type=None, data_type="stream", config_key="default", **kwargs):
-        """
-        初始化OSS
-        Args:
-            storage_type (str): 存储类型，目前支持ks3和file
-            data_type (str): 数据类型，目前支持stream和file_path
-            storage_config (dict): 存储配置，目前支持ks3和file,file_name,aliyun,minio
-        """
-        storage_config_setting = app_config.get("STORAGE_CONFIG", {})
-        storage_config = copy.deepcopy(storage_config_setting) or dict()
-        _storage_config = storage_config.get(config_key, {}) or dict()
-        _storage_config_storage_type = _storage_config.get("storage_type", "")
-        _storage_type = storage_type if storage_type else _storage_config_storage_type
-        _config_storage_config = _storage_config.get("storage_config", {})
-        _config_bucket_name = _config_storage_config.pop("bucket_name", "")
-        self.storage_type = _storage_type
-        self.data_type = data_type
-        self.storage_config = kwargs.get("storage_config", {}) if kwargs.get("storage_config",
-                                                                             {}) else _config_storage_config
-        self.bucket_name = kwargs.get("bucket_name") or _config_bucket_name
-
-    def _save(self, key, io_stream: BytesIO = None, file_path: str = None, bucket_name: str = None):
-        file_url_obj = dict()
-        if self.storage_type == "ks3":
-            if self.data_type == "stream":
-                storage_config = self.storage_config or dict()
-                ks3 = Ks3Oss(bucket_name=bucket_name or self.bucket_name, **storage_config)
-                url = ks3.save(key=key, string_data=io_stream.getvalue(), content_type="string", policy="public-read",
-                               bucket_name=bucket_name or self.bucket_name)
-                file_url_obj = {"key": key, "url": url}
-            elif self.data_type == "file_path":
-                storage_config = self.storage_config or dict()
-                ks3 = Ks3Oss(bucket_name=bucket_name or self.bucket_name, **storage_config)
-                url = ks3.save(key=key, filename=file_path, content_type="filename", policy="public-read")
-                file_url_obj = {"key": key, "url": url}
-        elif self.storage_type == "aliyun":
-            storage_config = self.storage_config or dict()
-            aliyun = AliYunOss(bucket_name=bucket_name or self.bucket_name, **storage_config)
-            url = aliyun.save(key=key, content_type="string", data=io_stream.getvalue(),
-                              bucket_name=bucket_name or self.bucket_name)
-            file_url_obj = {"key": key, "url": url}
-        elif self.storage_type == "minio":
-            storage_config = self.storage_config or dict()
-            minio = MinioOss(**storage_config)
-            url = minio.save(key=key, content_type="string", data=io_stream.getvalue(),
-                             bucket_name=bucket_name or self.bucket_name)
-            file_url_obj = {"key": key, "url": url}
-        elif self.storage_type == "file":
-            storage_path = ""
-            storage_dir = self.storage_config.get("STORAGE_DIR", "")
-            if not storage_dir:
-                raise Exception("storage_dir is empty")
-            if self.data_type == "stream":
-                if "\\" in key:
-                    key_list = key.split("\\")
-                elif "/" in key:
-                    key_list = key.split("/")
-                else:
-                    key_list = [key]
-                storage_path = storage_dir
-                if key_list:
-                    for k in key_list:
-                        storage_path = os.path.join(storage_path, k)
-                dir_path = os.path.dirname(storage_path)
-                if not os.path.exists(dir_path):
-                    os.makedirs(dir_path)
-            elif self.data_type == "file_path":
-                with open(file_path, 'rb') as infile:
-                    io_stream = BytesIO(infile.read())
-            if storage_path:
-                with open(storage_path, 'wb') as outfile:
-                    outfile.write(io_stream.getvalue())
-                file_url_obj = {"key": key, "url": storage_path}
-        return file_url_obj
-
-    def upload(self, **kwargs):
-        """上传文件
-        Args:
-            files (list): 文件列表 可以是文件流列表，也可以是字典列表，字典格式为{"key":"文件key，可以是带路径的文件","stream":"文件流"}
-        Returns:
-            file_url_list: 文件url列表[{"key":"文件key，可以是带路径的文件","url":"本地文件存储的文件的全路径，对象存储，存放的是文件的下载地址"}]
-        """
-        file_url_list = []
-        files = kwargs.get("files", [])
-        bucket_name = kwargs.get("bucket_name", self.bucket_name)
-        if not files:
-            raise Exception("files is empty")
-        if self.data_type == "stream":
-            for f in files:
-                if not isinstance(f, dict):
-                    key = f.filename
-                    stream = f.stream.read()
-                    file_stream = BytesIO(stream)
-                else:
-                    key = f.get("key", "")
-                    _steam = f.get("stream")
-                    stream = _steam.stream.read()
-                    file_stream = BytesIO(stream)
-                file_url_obj = self._save(key=key, io_stream=file_stream, bucket_name=bucket_name)
-                file_url_list.append(file_url_obj)
-
-        elif self.data_type == "file_path":
-            for f in files:
-                if not isinstance(f, dict):
-                    if "\\" in f:
-                        file_name = f.split("\\")[-1]
-                    elif "/" in f:
-                        file_name = f.split("/")[-1]
-                    else:
-                        file_name = f
-                    key = file_name
-                    _file_path = f
-                else:
-                    key = f.get("key", "")
-                    _file_path = f.get("file_path")
-                file_url_obj = self._save(key=key, file_path=_file_path, bucket_name=bucket_name)
-                file_url_list.append(file_url_obj)
-        return file_url_list
-
-    def download(self, key, bucket_name=None):
-        """下载文件，返回文件流
-        Args:
-            key (str): 上面接口返回的文件key
-        Returns:
-            file_stream: 文件流
-            :param bucket_name:
-        """
-        if self.storage_type == "ks3":
-            storage_config = self.storage_config or dict()
-            ks3 = Ks3Oss(bucket_name=self.bucket_name, **storage_config)
-            return ks3.get_file(key=key, bucket_name=bucket_name or self.bucket_name)
-        elif self.storage_type == "aliyun":
-            storage_config = self.storage_config or dict()
-            aliyun = AliYunOss(bucket_name=self.bucket_name, **storage_config)
-            return aliyun.get_file(key=key, bucket_name=bucket_name or self.bucket_name)
-        elif self.storage_type == "minio":
-            storage_config = self.storage_config or dict()
-            minio = MinioOss(**storage_config)
-            return minio.get_file(bucket_name=bucket_name or self.bucket_name, key=key)
-        if self.storage_type == "file":
-            storage_dir = self.storage_config.get("STORAGE_DIR", "")
-            if "\\" in key:
-                key_list = key.split("\\")
-            elif "/" in key:
-                key_list = key.split("/")
-            else:
-                key_list = [key]
-            file_path = storage_dir
-            if key_list:
-                for k in key_list:
-                    file_path = os.path.join(file_path, k)
-            with open(file_path, 'rb') as f:
-                return f.read()
-        return None