lesscode-flask 0.2.121__tar.gz → 0.2.123__tar.gz

{lesscode_flask-0.2.121 → lesscode_flask-0.2.123}/PKG-INFO

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

{lesscode_flask-0.2.121 → lesscode_flask-0.2.123}/lesscode_flask/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.2.121"
+__version__ = "0.2.123"
 
 import functools
 import logging

{lesscode_flask-0.2.121 → lesscode_flask-0.2.123}/lesscode_flask/export_data/data_download_handler.py

@@ -10,7 +10,7 @@ from openpyxl import Workbook
 
 from lesscode_flask.utils.file.file_utils import check_or_create_dir
 from lesscode_flask.utils.helpers import app_config
-from lesscode_flask.utils.oss import Ks3Oss
+from lesscode_flask.utils.oss import CommonOss, Ks3Oss
 
 download_func_dict = {}
 
@@ -50,8 +50,10 @@ def upload_result_url(data_list: list, file_name: str = None, describe_text: str
     file_key = f'data_download/{datetime_file_name}'
     path = check_or_create_dir(f'{current_app.config.get("STATIC_PATH", "")}/{file_key}')
     clear_excel_task()
+    # 生成下载地址
     if app_config.get("DATA_DOWNLOAD_WAY", "url") == "url":
         wb.save(path)
+        # 这个if是为了保证旧项目可以正常使用
         if app_config.get("DATA_DOWNLOAD_UPLOAD_KS3"):
             ks = Ks3Oss()
             bucket_name = app_config.get("KS3_CONNECT_CONFIG", {}).get("bucket_name")
@@ -59,8 +61,14 @@ def upload_result_url(data_list: list, file_name: str = None, describe_text: str
                           policy="public-read",
                           filename=path, content_type="filename")
             return url
+        # 生成下载地址的建议使用这个，兼容ks3,aliyun,minio,rustfs,file
+        elif app_config.get("DATA_DOWNLOAD_UPLOAD_COMMON_ENABLE"):
+            oss = CommonOss(config_key=app_config.get("DATA_DOWNLOAD_UPLOAD_COMMON_KEY"), data_type="file_path")
+            file_url_list = oss.upload(files=[{"key": file_key, "file_path": path}])
+            return file_url_list[0].get("url")
         else:
             return f'{current_app.config.get("OUTSIDE_SCREEN_IP")}/static/{file_key}'
+    # 生成文件流
     else:
         output = io.BytesIO()
         wb.save(output)

{lesscode_flask-0.2.121 → lesscode_flask-0.2.123}/lesscode_flask/utils/oss/__init__.py

@@ -42,11 +42,23 @@ class CommonOss:
         ── 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, 必填) : 默认操作的桶名
+                access_key_id     (str, 必填)  : KS3 Access Key ID
+                access_key_secret (str, 必填)  : KS3 Access Key Secret
+                host              (str, 必填)  : KS3 服务域名，例如 "ks3-cn-beijing.ksyun.com"
+                port              (int, 可选)  : 端口，默认 80
+                provider          (str, 可选)  : 服务提供商标识，默认 "kss"
+                security_token    (str, 可选)  : 安全令牌（临时凭证场景）
+                profile_name      (str, 可选)  : 配置文件名称
+                path              (str, 可选)  : 服务路径，默认 "/"
+                is_secure         (bool, 可选) : 是否启用 HTTPS，默认 False
+                debug             (int, 可选)  : 调试级别，默认 0
+                calling_format    (obj, 可选)  : 调用格式对象（如 SubdomainCallingFormat）
+                domain_mode       (bool, 可选) : 是否使用自定义域名，默认 False
+                local_encrypt     (bool, 可选) : 是否启用本地加密，默认 False
+                local_key_path    (str, 可选)  : 本地密钥路径，默认空字符串
+                timeout           (int, 可选)  : 超时秒数，默认 10
+                ua_addon          (str, 可选)  : User-Agent 附加信息，默认空字符串
+                bucket_name       (str, 必填)  : 默认操作的桶名
             STORAGE_CONFIG 示例：
                 "storage_config": {
                     "access_key_id": "your-access-key-id",
@@ -71,9 +83,12 @@ class CommonOss:
                 protocol          (str, 可选) : URL 协议，默认 "https"
                 session           (obj, 可选) : oss2 Session 对象
                 connect_timeout   (int, 可选) : 连接超时秒数
+                app_name          (str, 可选) : User-Agent 应用名称标识
                 proxies           (dict, 可选): 代理配置
                 cloudbox_id       (str, 可选) : 云盒 ID（云盒场景使用）
                 is_path_style     (bool, 可选): 是否使用 Path-Style 访问，默认 False
+                is_cname          (bool, 可选): 是否使用自定义域名（CNAME），默认 False
+                enable_crc        (bool, 可选): 是否启用 CRC 校验，默认 True
             STORAGE_CONFIG 示例：
                 "storage_config": {
                     "access_key_id": "your-access-key-id",
@@ -88,11 +103,16 @@ class CommonOss:
         ── 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, 必填) : 默认操作的桶名
+                service       (str, 必填) : MinIO 服务地址（不含协议），例如 "127.0.0.1:9000"
+                access_key    (str, 必填) : MinIO Access Key（用户名）
+                secret_key    (str, 必填) : MinIO Secret Key（密码）
+                session_token (str, 可选) : Session Token（临时凭证场景）
+                secure        (bool, 可选): 是否启用 HTTPS，默认 False
+                region        (str, 可选) : S3 Region，默认 None
+                http_client   (obj, 可选) : urllib3.PoolManager 实例
+                credentials   (obj, 可选) : 自定义凭证提供者
+                cert_check    (bool, 可选): 是否验证 SSL 证书，默认 True
+                bucket_name   (str, 必填) : 默认操作的桶名
             STORAGE_CONFIG 示例：
                 "storage_config": {
                     "service": "127.0.0.1:9000",
@@ -107,14 +127,16 @@ class CommonOss:
         ── 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, 必填) : 默认操作的桶名
+                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 通常不校验）
+                aws_session_token (str, 可选) : AWS Session Token（临时凭证场景）
+                verify            (bool, 可选): 是否验证 SSL 证书，默认 True
+                bucket_name       (str, 必填) : 默认操作的桶名
             STORAGE_CONFIG 示例：
                 "storage_config": {
                     "endpoint": "http://127.0.0.1:9000",
@@ -160,32 +182,80 @@ class CommonOss:
     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":
+            storage_config = self.storage_config or dict()
+            ks3 = Ks3Oss(
+                access_key_id=storage_config.get("access_key_id"),
+                access_key_secret=storage_config.get("access_key_secret"),
+                host=storage_config.get("host"),
+                port=storage_config.get("port", 80),
+                provider=storage_config.get("provider", "kss"),
+                security_token=storage_config.get("security_token"),
+                profile_name=storage_config.get("profile_name"),
+                path=storage_config.get("path", "/"),
+                is_secure=storage_config.get("is_secure", False),
+                debug=storage_config.get("debug", 0),
+                calling_format=storage_config.get("calling_format"),
+                domain_mode=storage_config.get("domain_mode", False),
+                local_encrypt=storage_config.get("local_encrypt", False),
+                local_key_path=storage_config.get("local_key_path", ""),
+                timeout=storage_config.get("timeout", 10),
+                ua_addon=storage_config.get("ua_addon", ""),
+                bucket_name=bucket_name or self.bucket_name
+            )
             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)
+            aliyun = AliYunOss(
+                access_key_id=storage_config.get("access_key_id"),
+                access_key_secret=storage_config.get("access_key_secret"),
+                endpoint=storage_config.get("endpoint"),
+                bucket_name=bucket_name or self.bucket_name,
+                region=storage_config.get("region"),
+                session=storage_config.get("session"),
+                connect_timeout=storage_config.get("connect_timeout"),
+                app_name=storage_config.get("app_name"),
+                proxies=storage_config.get("proxies"),
+                cloudbox_id=storage_config.get("cloudbox_id"),
+                is_path_style=storage_config.get("is_path_style", False),
+                is_cname=storage_config.get("is_cname", False),
+                enable_crc=storage_config.get("enable_crc", True)
+            )
             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)
+            minio = MinioOss(
+                endpoint=storage_config.get("service"),
+                access_key=storage_config.get("access_key"),
+                secret_key=storage_config.get("secret_key"),
+                session_token=storage_config.get("session_token"),
+                secure=storage_config.get("secure", False),
+                region=storage_config.get("region"),
+                http_client=storage_config.get("http_client"),
+                credentials=storage_config.get("credentials"),
+                cert_check=storage_config.get("cert_check", True)
+            )
             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)
+            rustfs = RustfsOss(
+                endpoint=storage_config.get("endpoint"),
+                access_key=storage_config.get("access_key"),
+                secret_key=storage_config.get("secret_key"),
+                secure=storage_config.get("secure", False),
+                region=storage_config.get("region", "us-east-1"),
+                aws_session_token=storage_config.get("aws_session_token"),
+                verify=storage_config.get("verify", True)
+            )
             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}
@@ -321,19 +391,69 @@ class CommonOss:
         """
         if self.storage_type == "ks3":
             storage_config = self.storage_config or dict()
-            ks3 = Ks3Oss(bucket_name=self.bucket_name, **storage_config)
+            ks3 = Ks3Oss(
+                access_key_id=storage_config.get("access_key_id"),
+                access_key_secret=storage_config.get("access_key_secret"),
+                host=storage_config.get("host"),
+                port=storage_config.get("port", 80),
+                provider=storage_config.get("provider", "kss"),
+                security_token=storage_config.get("security_token"),
+                profile_name=storage_config.get("profile_name"),
+                path=storage_config.get("path", "/"),
+                is_secure=storage_config.get("is_secure", False),
+                debug=storage_config.get("debug", 0),
+                calling_format=storage_config.get("calling_format"),
+                domain_mode=storage_config.get("domain_mode", False),
+                local_encrypt=storage_config.get("local_encrypt", False),
+                local_key_path=storage_config.get("local_key_path", ""),
+                timeout=storage_config.get("timeout", 10),
+                ua_addon=storage_config.get("ua_addon", ""),
+                bucket_name=self.bucket_name
+            )
             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)
+            aliyun = AliYunOss(
+                access_key_id=storage_config.get("access_key_id"),
+                access_key_secret=storage_config.get("access_key_secret"),
+                endpoint=storage_config.get("endpoint"),
+                bucket_name=self.bucket_name,
+                region=storage_config.get("region"),
+                session=storage_config.get("session"),
+                connect_timeout=storage_config.get("connect_timeout"),
+                app_name=storage_config.get("app_name"),
+                proxies=storage_config.get("proxies"),
+                cloudbox_id=storage_config.get("cloudbox_id"),
+                is_path_style=storage_config.get("is_path_style", False),
+                is_cname=storage_config.get("is_cname", False),
+                enable_crc=storage_config.get("enable_crc", True)
+            )
             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)
+            minio = MinioOss(
+                endpoint=storage_config.get("service"),
+                access_key=storage_config.get("access_key"),
+                secret_key=storage_config.get("secret_key"),
+                session_token=storage_config.get("session_token"),
+                secure=storage_config.get("secure", False),
+                region=storage_config.get("region"),
+                http_client=storage_config.get("http_client"),
+                credentials=storage_config.get("credentials"),
+                cert_check=storage_config.get("cert_check", True)
+            )
             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)
+            rustfs = RustfsOss(
+                endpoint=storage_config.get("endpoint"),
+                access_key=storage_config.get("access_key"),
+                secret_key=storage_config.get("secret_key"),
+                secure=storage_config.get("secure", False),
+                region=storage_config.get("region", "us-east-1"),
+                aws_session_token=storage_config.get("aws_session_token"),
+                verify=storage_config.get("verify", True)
+            )
             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", "")

{lesscode_flask-0.2.121 → lesscode_flask-0.2.123}/lesscode_flask/utils/oss/aliyun_oss.py

@@ -8,7 +8,8 @@ from lesscode_flask.utils.helpers import app_config
 class AliYunOss:
     def __init__(self, **kwargs):
         try:
-            oss2 = importlib.import_module("oss2")
+            # oss2 = importlib.import_module("oss2")
+            import oss2
         except ImportError:
             raise Exception(f"oss2 is not exist,run:pip install oss2")
         bucket_name = kwargs.pop("bucket_name", "") if kwargs.get("bucket_name") else app_config.get(
@@ -24,12 +25,16 @@ class AliYunOss:
         self.endpoint = kwargs.pop("endpoint", "") if kwargs.get("endpoint") else app_config.get(
             "ALIYUN_CONNECT_CONFIG").get(
             "endpoint")
+        self.session = kwargs.pop("session", None)
+        self.connect_timeout = kwargs.pop("connect_timeout", None)
+        self.is_cname = kwargs.pop("is_cname", False)
+        self.enable_crc = kwargs.pop("enable_crc", True)
         config = {
             "auth": self.auth,
             "endpoint": self.endpoint,
-            "session": kwargs.pop("session", None),
-            "connect_timeout": kwargs.pop("connect_timeout", None),
-            "app_name": kwargs.pop("connect_timeout", ''),
+            "session": self.session,
+            "connect_timeout": self.connect_timeout,
+            "app_name": kwargs.pop("app_name", ''),
             "proxies": kwargs.pop("proxies", None),
             "region": kwargs.pop("region", None),
             "cloudbox_id": kwargs.pop("cloudbox_id", None),
@@ -37,7 +42,11 @@ class AliYunOss:
         }
         self.client = oss2.Service(**config)
         if bucket_name is not None:
-            self.instance = oss2.Bucket(auth=self.auth, endpoint=self.endpoint, bucket_name=bucket_name)
+            self.instance = oss2.Bucket(
+                auth=self.auth, endpoint=self.endpoint, bucket_name=bucket_name,
+                is_cname=self.is_cname, session=self.session,
+                connect_timeout=self.connect_timeout, enable_crc=self.enable_crc
+            )
         else:
             self.instance = None
 
@@ -47,7 +56,11 @@ class AliYunOss:
         except ImportError:
             raise Exception(f"oss2 is not exist,run:pip install oss2")
         if bucket_name:
-            self.instance = oss2.Bucket(auth=self.auth, endpoint=self.endpoint, bucket_name=bucket_name)
+            self.instance = oss2.Bucket(
+                auth=self.auth, endpoint=self.endpoint, bucket_name=bucket_name,
+                is_cname=self.is_cname, session=self.session,
+                connect_timeout=self.connect_timeout, enable_crc=self.enable_crc
+            )
         return self.instance
 
     def create_bucket(self, bucket_name, **kwargs):
@@ -128,7 +141,11 @@ class AliYunOss:
         except ImportError:
             raise Exception(f"oss2 is not exist,run:pip install oss2")
         if bucket_name:
-            self.instance = oss2.Bucket(auth=self.auth, endpoint=self.endpoint, bucket_name=bucket_name)
+            self.instance = oss2.Bucket(
+                auth=self.auth, endpoint=self.endpoint, bucket_name=bucket_name,
+                is_cname=self.is_cname, session=self.session,
+                connect_timeout=self.connect_timeout, enable_crc=self.enable_crc
+            )
         return self.instance.put_bucket_referer(models.BucketReferer(**kwargs))
 
     def get_bucket_cors(self, bucket_name=None):

{lesscode_flask-0.2.121 → lesscode_flask-0.2.123}/lesscode_flask/utils/oss/ks3_oss.py

@@ -1,30 +1,53 @@
 import importlib
-import os
-
 import math
+import os
 
 from lesscode_flask.utils.helpers import app_config
 
 
 class Ks3Oss:
-    def __init__(self, **kwargs):
-        if not kwargs.get("access_key_id"):
-            kwargs.update({"access_key_id": app_config.get("KS3_CONNECT_CONFIG").get("access_key_id")})
-        if not kwargs.get("access_key_secret"):
-            kwargs.update({"access_key_secret": app_config.get("KS3_CONNECT_CONFIG").get("access_key_secret")})
-        if not kwargs.get("host"):
-            kwargs.update({"host": app_config.get("KS3_CONNECT_CONFIG").get("host")})
-        if not kwargs.get("is_secure"):
-            if app_config.get("KS3_CONNECT_CONFIG").get("is_secure"):
-                kwargs.update({"is_secure": app_config.get("KS3_CONNECT_CONFIG").get("is_secure")})
-        bucket_name = kwargs.pop("bucket_name", None)
+    def __init__(self, access_key_id=None, access_key_secret=None, host=None, port=80,
+                 provider='kss', security_token=None, profile_name=None, path='/',
+                 is_secure=False, debug=0, calling_format=None, domain_mode=False,
+                 local_encrypt=False, local_key_path='', timeout=10, ua_addon='',
+                 bucket_name=None):
+        if not access_key_id:
+            access_key_id = app_config.get("KS3_CONNECT_CONFIG").get("access_key_id")
+        if not access_key_secret:
+            access_key_secret = app_config.get("KS3_CONNECT_CONFIG").get("access_key_secret")
+        if not host:
+            host = app_config.get("KS3_CONNECT_CONFIG").get("host")
         if bucket_name is None:
             bucket_name = app_config.get("KS3_CONNECT_CONFIG").get("bucket_name")
         try:
             ks3_connection = importlib.import_module("ks3.connection")
         except ImportError:
             raise Exception(f"ks3sdk is not exist,run:pip install ks3sdk==1.5.0")
-        self.client = ks3_connection.Connection(**kwargs)
+
+        # 准备构造参数
+        conn_kwargs = {
+            'host': host,
+            'port': port,
+            'provider': provider,
+            'security_token': security_token,
+            'profile_name': profile_name,
+            'path': path,
+            'is_secure': is_secure,
+            'debug': debug,
+            'domain_mode': domain_mode,
+            'local_encrypt': local_encrypt,
+            'local_key_path': local_key_path,
+            'timeout': timeout,
+            'ua_addon': ua_addon
+        }
+
+        # 如果提供了 calling_format，则添加
+        if calling_format is not None:
+            conn_kwargs['calling_format'] = calling_format
+
+        self.client = ks3_connection.Connection(
+            access_key_id, access_key_secret, **conn_kwargs
+        )
         if bucket_name is not None:
             self.instance = self.client.get_bucket(bucket_name)
         else:

{lesscode_flask-0.2.121 → lesscode_flask-0.2.123}/lesscode_flask/utils/oss/minio_oss.py

@@ -15,13 +15,24 @@ class MinioOss:
             cls.client = object.__new__(cls)
         return cls.client
 
-    def __init__(self, service, access_key, secret_key, secure=False):
+    def __init__(self, endpoint, access_key, secret_key, session_token=None, secure=False,
+                 region=None, http_client=None, credentials=None, cert_check=True):
         try:
             minio = importlib.import_module("minio")
         except ImportError as e:
             raise Exception(f"minio is not exist,run:pip install minio")
-        self.service = service
-        self.client = minio.Minio(service, access_key=access_key, secret_key=secret_key, secure=secure)
+        self.endpoint = endpoint
+        self.client = minio.Minio(
+            endpoint,
+            access_key=access_key,
+            secret_key=secret_key,
+            session_token=session_token,
+            secure=secure,
+            region=region,
+            http_client=http_client,
+            credentials=credentials,
+            cert_check=cert_check
+        )
 
     def exists_bucket(self, bucket_name):
         """

{lesscode_flask-0.2.121 → lesscode_flask-0.2.123}/lesscode_flask/utils/oss/rustfs_oss.py

@@ -10,7 +10,8 @@ class RustfsOss:
     RustFS is an S3-compatible object storage written in Rust.
     """
 
-    def __init__(self, endpoint, access_key, secret_key, secure=False, region="us-east-1"):
+    def __init__(self, endpoint, access_key, secret_key, secure=False, region="us-east-1",
+                 aws_session_token=None, verify=True):
         try:
             boto3 = importlib.import_module("boto3")
         except ImportError:
@@ -26,7 +27,9 @@ class RustfsOss:
             endpoint_url=endpoint_url,
             aws_access_key_id=access_key,
             aws_secret_access_key=secret_key,
+            aws_session_token=aws_session_token,
             region_name=region,
+            verify=verify,
         )
 
     # ------------------------------------------------------------------

{lesscode_flask-0.2.121 → lesscode_flask-0.2.123}/lesscode_flask.egg-info/PKG-INFO

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