lesscode-flask 0.1.77__tar.gz → 0.1.79__tar.gz

{lesscode-flask-0.1.77 → lesscode_flask-0.1.79}/PKG-INFO

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

{lesscode-flask-0.1.77 → lesscode_flask-0.1.79}/lesscode_flask/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '0.1.77'
+__version__ = '0.1.79'
 
 import functools
 import logging

{lesscode-flask-0.1.77 → lesscode_flask-0.1.79}/lesscode_flask/log/access_log_handler.py

@@ -54,7 +54,10 @@ class AccessLogHandler(Handler):
         except Exception as e:
             pass
         location: str = iputil.get_region(client_ip)
-        current_user = flask_login.current_user
+        if hasattr(request, "user"):
+            current_user = getattr(request, "user")
+        else:
+            current_user = flask_login.current_user
         access_log = AccessLog(request_id=request_id, display_name=current_user.display_name,
                                obj_id=current_user.id, type=current_user.type, client_id=client_id,
                                resource_id=resource_id, location=location,sub=current_user.sub,

{lesscode-flask-0.1.77 → lesscode_flask-0.1.79}/lesscode_flask/utils/oss/__init__.py

@@ -2,7 +2,9 @@ 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:
@@ -12,7 +14,7 @@ class CommonOss:
         Args:
             storage_type (str): 存储类型，目前支持ks3和file
             data_type (str): 数据类型，目前支持stream和file_path
-            storage_config (dict): 存储配置，目前支持ks3和file,file_name
+            storage_config (dict): 存储配置，目前支持ks3和file,file_name,aliyun,minio
         """
         _storage_config = app_config.get("STORAGE_CONFIG", {}).get(config_key, {}) or dict()
         self.storage_type = storage_type if storage_type else _storage_config.get("storage_type", "")
@@ -20,25 +22,37 @@ class CommonOss:
         self.storage_config = kwargs.get("storage_config", {}) if kwargs.get("storage_config",
                                                                              {}) else _storage_config.get(
             "storage_config", {})
+        self.bucket_name = kwargs.get("bucket_name") or self.storage_config.pop("bucket_name", "")
 
-    def _save(self, key, io_stream: BytesIO = None, file_path: str = None):
+    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(**storage_config)
-                url = ks3.save(key=key, string_data=io_stream.getvalue(), content_type="string", policy="public-read")
+                ks3 = Ks3Oss(bucket_name=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(**storage_config)
+                ks3 = Ks3Oss(bucket_name=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=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:
-                storage_dir = app_config.get("STORAGE_DIR")
+            storage_dir = self.storage_config.get("STORAGE_DIR", "")
             if not storage_dir:
                 raise Exception("storage_dir is empty")
             if self.data_type == "stream":
@@ -73,6 +87,7 @@ class CommonOss:
         """
         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":
@@ -86,7 +101,7 @@ class CommonOss:
                     _steam = f.get("stream")
                     stream = _steam.stream.read()
                     file_stream = BytesIO(stream)
-                file_url_obj = self._save(key=key, io_stream=file_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":
@@ -103,25 +118,32 @@ class CommonOss:
                 else:
                     key = f.get("key", "")
                     _file_path = f.get("file_path")
-                file_url_obj = self._save(key=key, file_path=_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):
+    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(**storage_config)
-            return ks3.get_file(key)
+            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 not storage_dir:
-                storage_dir = app_config.get("STORAGE_DIR")
+            storage_dir = self.storage_config.get("STORAGE_DIR", "")
             if "\\" in key:
                 key_list = key.split("\\")
             elif "/" in key:
@@ -134,3 +156,4 @@ class CommonOss:
                     file_path = os.path.join(file_path, k)
             with open(file_path, 'rb') as f:
                 return f.read()
+        return None

lesscode_flask-0.1.79/lesscode_flask/utils/oss/aliyun_oss.py

@@ -0,0 +1,202 @@
+import importlib
+import os
+from typing import List
+
+from tornado.options import options
+
+
+class AliYunOss:
+    def __init__(self, **kwargs):
+        try:
+            oss2 = importlib.import_module("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 options.aliyun_connect_config.get(
+            "bucket_name")
+        auth_config = {
+            "access_key_id": kwargs.pop("access_key_id", "") if kwargs.get(
+                "access_key_id") else options.aliyun_connect_config.get("access_key_id"),
+            "access_key_secret": kwargs.pop("access_key_secret", "") if kwargs.get(
+                "access_key_secret") else options.aliyun_connect_config.get("access_key_secret")
+        }
+        self.auth = oss2.Auth(**auth_config)
+        self.endpoint = kwargs.pop("endpoint", "") if kwargs.get("endpoint") else options.aliyun_connect_config.get(
+            "endpoint")
+        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", ''),
+            "proxies": kwargs.pop("proxies", None),
+            "region": kwargs.pop("region", None),
+            "cloudbox_id": kwargs.pop("cloudbox_id", None),
+            "is_path_style": kwargs.pop("is_path_style", False)
+        }
+        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)
+        else:
+            self.instance = None
+
+    def get_bucket_instance(self, bucket_name=None):
+        try:
+            oss2 = importlib.import_module("oss2")
+        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)
+        return self.instance
+
+    def create_bucket(self, bucket_name, **kwargs):
+        if not self.instance:
+            self.instance = self.get_bucket_instance(bucket_name)
+        bucket = self.instance.create_bucket(**kwargs)
+        return bucket
+
+    def list_buckets(self, **kwargs):
+        try:
+            oss2 = importlib.import_module("oss2")
+        except ImportError:
+            raise Exception(f"oss2 is not exist,run:pip install oss2")
+        return [b.name for b in oss2.BucketIterator(self.client, **kwargs)]
+
+    def delete_bucket(self, bucket_name):
+        if not self.instance:
+            self.instance = self.get_bucket_instance(bucket_name)
+        return self.instance.delete_bucket()
+
+    def save(self, key, content_type, data, bucket_name="", region="oss-cn-hangzhou", domain="aliyuncs.com",
+             protocol="https", **kwargs):
+        if bucket_name:
+            self.instance = self.get_bucket_instance(bucket_name)
+        if content_type == "filename":
+            self.instance.put_object_from_file(key=key, filename=data, **kwargs)
+        elif content_type == "network":
+            self.instance.put_object(key=key, data=data, **kwargs)
+        else:
+            self.instance.put_object(key=key, data=data, **kwargs)
+        return f'{protocol}://{self.instance.name}.{region}.{domain}/{key}'
+
+    def get_url(self, key, bucket_name="", region="oss-cn-hangzhou", domain="aliyuncs.com", protocol="https"):
+        if bucket_name:
+            self.instance = self.get_bucket_instance(bucket_name)
+        return f'{protocol}://{self.instance.name}.{region}.{domain}/{key}'
+
+    def get_file(self, key, bucket_name="", file_path=None, **kwargs):
+        if bucket_name:
+            self.instance = self.get_bucket_instance(bucket_name)
+        if file_path:
+            self.instance.get_object_to_file(key=key, filename=file_path, **kwargs)
+        else:
+            return self.instance.get_object(key=key, **kwargs)
+
+    def get_key(self, key, bucket_name="", **kwargs):
+        if bucket_name:
+            self.instance = self.get_bucket_instance(bucket_name)
+        k = self.instance.head_object(key, **kwargs)
+        return k
+
+    def delete_file(self, key, bucket_name=None, **kwargs):
+        if bucket_name:
+            self.instance = self.get_bucket_instance(bucket_name)
+        res = self.instance.delete_object(key, **kwargs)
+        return res
+
+    def list_file(self, bucket_name, **kwargs):
+        try:
+            oss2 = importlib.import_module("oss2")
+        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)
+        files = [k.key for k in oss2.ObjectIterator(self.instance, **kwargs)]
+        return files
+
+    def get_bucket_referer(self, bucket_name=None):
+        if bucket_name:
+            self.instance = self.get_bucket_instance(bucket_name)
+        acl = self.instance.get_bucket_referer()
+        return acl
+
+    def set_bucket_referer(self, bucket_name=None, **kwargs):
+        try:
+            oss2 = importlib.import_module("oss2")
+            models = importlib.import_module("oss2.models")
+        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)
+        return self.instance.put_bucket_referer(models.BucketReferer(**kwargs))
+
+    def get_bucket_cors(self, bucket_name=None):
+        if bucket_name:
+            self.instance = self.get_bucket_instance(bucket_name)
+        cors = self.instance.get_bucket_cors()
+        return cors
+
+    def set_bucket_cors(self, cors: List[dict], bucket_name=None):
+        try:
+            oss2 = importlib.import_module("oss2")
+            models = importlib.import_module("oss2.models")
+        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)
+        rules = [models.CorsRule(**_) for _ in cors]
+        return self.instance.put_bucket_cors(rules)
+
+    def delete_bucket_cors(self, bucket_name=None):
+        if bucket_name:
+            self.instance = self.get_bucket_instance(bucket_name)
+        return self.instance.delete_bucket_cors()
+
+    def multipart_upload(self, key, file_path, preferred_size, bucket_name=None, **kwargs):
+        try:
+            oss2 = importlib.import_module("oss2")
+            models = importlib.import_module("oss2.models")
+        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)
+        total_size = os.path.getsize(file_path)
+        part_size = oss2.determine_part_size(total_size, preferred_size=preferred_size)
+        upload_id = self.instance.init_multipart_upload(key).upload_id
+        parts = []
+        with open(file_path, 'rb') as f:
+            part_number = 1
+            offset = 0
+            while offset < total_size:
+                num_to_upload = min(part_size, total_size - offset)
+                result = self.instance.upload_part(key, upload_id, part_number,
+                                                   oss2.SizedFileAdapter(f, num_to_upload))
+                parts.append(models.PartInfo(part_number, result.etag))
+
+                offset += num_to_upload
+                part_number += 1
+        ret = self.instance.complete_multipart_upload(key, upload_id, parts, **kwargs)
+        return {"result": ret, "upload_id": upload_id}
+
+    def list_multipart_uploads(self, key, upload_id, bucket_name=None, **kwargs):
+        try:
+            oss2 = importlib.import_module("oss2")
+        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)
+        return oss2.PartIterator(self.instance, key, upload_id, **kwargs)
+
+    def get_sign_url(self, key, expires, bucket_name=None, headers=None, params=None, slash_safe=False):
+        if bucket_name:
+            self.instance = self.get_bucket_instance(bucket_name)
+        url = self.instance.sign_url('GET', key, expires, slash_safe=slash_safe, headers=headers, params=params)
+        return url
+
+    def modify_object(self, bucket_name=None, **kwargs):
+        if bucket_name:
+            self.instance = self.get_bucket_instance(bucket_name)
+        source_bucket_name = bucket_name if bucket_name else self.instance.name
+        return self.instance.copy_object(source_bucket_name=source_bucket_name, **kwargs)
+
+    def get_regions(self, regions):
+        return self.client.describe_regions(regions=regions)

lesscode_flask-0.1.79/lesscode_flask/utils/oss/minio_oss.py

@@ -0,0 +1,254 @@
+import importlib
+import logging
+import os
+
+from datetime import timedelta
+from io import BytesIO
+
+
+class MinioOss:
+    client = None
+    policy = '{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Principal":{"AWS":["*"]},"Action":["s3:GetBucketLocation","s3:ListBucket"],"Resource":["arn:aws:s3:::%s"]},{"Effect":"Allow","Principal":{"AWS":["*"]},"Action":["s3:GetObject"],"Resource":["arn:aws:s3:::%s/*"]}]}'
+
+    def __new__(cls, *args, **kwargs):
+        if not cls.client:
+            cls.client = object.__new__(cls)
+        return cls.client
+
+    def __init__(self, service, access_key, secret_key, secure=False):
+        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)
+
+    def exists_bucket(self, bucket_name):
+        """
+        判断桶是否存在
+        :param bucket_name: 桶名称
+        :return:
+        """
+        return self.client.bucket_exists(bucket_name=bucket_name)
+
+    def create_bucket(self, bucket_name: str, is_policy: bool = True):
+        """
+        创建桶 + 赋予策略
+        :param bucket_name: 桶名
+        :param is_policy: 策略
+        :return:
+        """
+        if self.exists_bucket(bucket_name=bucket_name):
+            return False
+        else:
+            self.client.make_bucket(bucket_name=bucket_name)
+        if is_policy:
+            policy = self.policy % (bucket_name, bucket_name)
+            self.client.set_bucket_policy(bucket_name=bucket_name, policy=policy)
+        return True
+
+    def get_bucket_list(self):
+        """
+        列出存储桶
+        :return:
+        """
+        buckets = self.client.list_buckets()
+        bucket_list = []
+        for bucket in buckets:
+            bucket_list.append(
+                {"bucket_name": bucket.name, "create_time": bucket.creation_date}
+            )
+        return bucket_list
+
+    def remove_bucket(self, bucket_name):
+        """
+        删除桶
+        :param bucket_name:
+        :return:
+        """
+        try:
+            minio_error = importlib.import_module("minio.error")
+        except ImportError as e:
+            raise Exception(f"minio is not exist,run:pip install minio")
+        try:
+            self.client.remove_bucket(bucket_name=bucket_name)
+        except minio_error.S3Error as e:
+            logging.error(f"[error]:{e}")
+            return False
+        return True
+
+    def bucket_list_files(self, bucket_name, prefix):
+        """
+        列出存储桶中所有对象
+        :param bucket_name: 同名
+        :param prefix: 前缀
+        :return:
+        """
+        try:
+            minio_error = importlib.import_module("minio.error")
+        except ImportError as e:
+            raise Exception(f"minio is not exist,run:pip install minio")
+        try:
+            files_list = self.client.list_objects(bucket_name=bucket_name, prefix=prefix, recursive=True)
+            return files_list
+        except minio_error.S3Error as e:
+            logging.error(f"[error]:{e}")
+            return None
+
+    def bucket_policy(self, bucket_name):
+        """
+        列出桶存储策略
+        :param bucket_name:
+        :return:
+        """
+        try:
+            minio_error = importlib.import_module("minio.error")
+        except ImportError as e:
+            raise Exception(f"minio is not exist,run:pip install minio")
+        try:
+            policy = self.client.get_bucket_policy(bucket_name)
+        except minio_error.S3Error as e:
+            logging.error(f"[error]:{e}")
+            return None
+        return policy
+
+    def download_file(self, bucket_name, file, file_path, stream=1024 * 32):
+        """
+        从bucket 下载文件 + 写入指定文件
+        :return:
+        """
+        try:
+            minio_error = importlib.import_module("minio.error")
+        except ImportError as e:
+            raise Exception(f"minio is not exist,run:pip install minio")
+        try:
+            data = self.client.get_object(bucket_name, file)
+            with open(file_path, "wb") as fp:
+                for d in data.stream(stream):
+                    fp.write(d)
+        except minio_error.S3Error as e:
+            logging.error(f"[error]:{e}")
+
+    def get_file(self, bucket_name, key):
+        data = self.client.get_object(bucket_name, object_name=key)
+        return data
+
+    def fget_file(self, bucket_name, file, file_path):
+        """
+        下载保存文件保存本地
+        :param bucket_name:
+        :param file:
+        :param file_path:
+        :return:
+        """
+        self.client.fget_object(bucket_name, file, file_path)
+
+    def copy_file(self, bucket_name, file, file_path):
+        """
+        拷贝文件（最大支持5GB）
+        :param bucket_name:
+        :param file:
+        :param file_path:
+        :return:
+        """
+        self.client.copy_object(bucket_name, file, file_path)
+
+    def upload_file(self, bucket_name, file, file_path, content_type):
+        """
+        上传文件 + 写入
+        :param bucket_name: 桶名
+        :param file: 文件名
+        :param file_path: 本地文件路径
+        :param content_type: 文件类型
+        :return:
+        """
+        try:
+            minio_error = importlib.import_module("minio.error")
+        except ImportError as e:
+            raise Exception(f"minio is not exist,run:pip install minio")
+        try:
+            with open(file_path, "rb") as file_data:
+                file_stat = os.stat(file_path)
+                self.client.put_object(bucket_name, file, file_data, file_stat.st_size, content_type=content_type)
+        except minio_error.S3Error as e:
+            logging.error(f"[error]:{e}")
+
+    def save(self, key, bucket_name, data, content_type="string", **kwargs):
+        ret = None
+        if content_type == "string":
+            ret = self.client.put_object(bucket_name=bucket_name, object_name=key, data=BytesIO(data), length=len(data),
+                                         **kwargs)
+        elif content_type == "filename":
+            with open(data, "rb") as f:
+                data = f.read()
+            ret = self.client.put_object(bucket_name=bucket_name, object_name=key, data=BytesIO(data), length=len(data),
+                                         **kwargs)
+        if ret:
+            if ret.status == 200:
+                return self.client.presigned_get_object(bucket_name=bucket_name, key=key, expires=3600)
+            else:
+                return False
+        else:
+            return False
+
+    def fput_file(self, bucket_name, file, file_path):
+        """
+        上传文件
+        :param bucket_name: 桶名
+        :param file: 文件名
+        :param file_path: 本地文件路径
+        :return:
+        """
+        try:
+            minio_error = importlib.import_module("minio.error")
+        except ImportError as e:
+            raise Exception(f"minio is not exist,run:pip install minio")
+        try:
+            self.client.fput_object(bucket_name, file, file_path)
+        except minio_error.S3Error as e:
+            logging.error(f"[error]:{e}")
+
+    def stat_object(self, bucket_name, file):
+        """
+        获取文件元数据
+        :param bucket_name:
+        :param file:
+        :return:
+        """
+        try:
+            minio_error = importlib.import_module("minio.error")
+        except ImportError as e:
+            raise Exception(f"minio is not exist,run:pip install minio")
+        try:
+            data = self.client.stat_object(bucket_name, file)
+            return data
+        except minio_error.S3Error as e:
+            logging.error(f"[error]:{e}")
+            return None
+
+    def remove_file(self, bucket_name, file):
+        """
+        移除单个文件
+        :return:
+        """
+        self.client.remove_object(bucket_name, file)
+
+    def remove_files(self, bucket_name, file_list):
+        """
+        删除多个文件
+        :return:
+        """
+        try:
+            deleteobjects = importlib.import_module("minio.deleteobjects")
+        except ImportError as e:
+            raise Exception(f"minio is not exist,run:pip install minio")
+        delete_object_list = [deleteobjects.DeleteObject(file) for file in file_list]
+        for del_err in self.client.remove_objects(bucket_name, delete_object_list):
+            logging.error(del_err)
+
+    def presigned_get_file(self, bucket_name, file, days=7):
+        """
+        生成一个http GET操作 签证URL
+        :return:
+        """
+        return self.client.presigned_get_object(bucket_name, file, expires=timedelta(days=days))

{lesscode-flask-0.1.77 → lesscode_flask-0.1.79}/lesscode_flask.egg-info/PKG-INFO

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

{lesscode-flask-0.1.77 → lesscode_flask-0.1.79}/lesscode_flask.egg-info/SOURCES.txt

@@ -36,7 +36,9 @@ lesscode_flask/utils/file/file_exporter.py
 lesscode_flask/utils/file/file_utils.py
 lesscode_flask/utils/json/NotSortJSONProvider.py
 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/redis/redis_helper.py
 lesscode_flask/utils/request/request.py
 lesscode_flask/utils/swagger/swagger_template.py