lesscode-flask 0.0.27__py3-none-any.whl

lesscode_flask/setting/__init__.py

@@ -0,0 +1,122 @@
+import os
+import sys
+
+from flask import current_app
+
+from lesscode_flask.utils.helpers import get_start_port
+
+
+class BaseConfig:
+    # 应用名称
+    APPLICATION_NAME: str = ""
+    # 应用id
+    CLIENT_ID: str = ""
+    # 项目名称
+    PROJECT_NAME: str = ""
+    # 统一路由前缀
+    ROUTE_PREFIX = ""
+    # 项目端口号
+    PORT = 5002
+
+    # 数据源
+    DATA_SOURCE = []
+    # SQLALCHEMY数据库连接
+    SQLALCHEMY_BINDS = {
+        # 'users': 'mysqldb://localhost/users',
+        # 'appmeta': 'sqlite:////path/to/appmeta.db'
+    }
+
+    # 日志级别
+    LESSCODE_LOG_LEVEL = os.environ.get("LESSCODE_LOG_LEVEL", "INFO")
+    # 日志格式
+    LESSCODE_LOG_FORMAT = os.environ.get("LESSCODE_LOG_FORMAT",
+                                         '[%(asctime)s] [%(levelname)s] [%(name)s:%(module)s:%(lineno)d] [%(message)s]')
+    # 输出管道
+    LESSCODE_LOG_STDOUT = os.environ.get("LESSCODE_LOG_STDOUT", True)
+    # 日志文件备份数量
+    LESSCODE_LOG_FILE_BACKUPCOUNT = os.environ.get("LESSCODE_LOG_FILE_BACKUPCOUNT", 7)
+    # 日志文件分割周期
+    LESSCODE_LOG_LOG_FILE_WHEN = os.environ.get("LESSCODE_LOG_LOG_FILE_WHEN", "D")
+    # 日志文件存储路径
+    LESSCODE_LOG_FILE_PATH = os.environ.get("LESSCODE_LOG_FILE_PATH", 'logs/lesscode.log')
+    # 访问日志是否DB存储
+    LESSCODE_ACCESS_LOG_DB = os.environ.get("LESSCODE_ACCESS_LOG_DB", 0)
+    # 未配置权限的资源 默认权限  1：需要登录 0：游客'
+    AUTH_DEFAULT_ACCESS = 0
+
+    # 外网地址
+    OUTSIDE_SCREEN_IP: str = "http://127.0.0.1:{}".format(get_start_port())
+    SWAGGER_URL = '{}/swagger-ui'.format(ROUTE_PREFIX)
+    SWAGGER_API_URL = '{}/swagger'.format(ROUTE_PREFIX)
+    NOT_RESPONSE_RESULT = [SWAGGER_URL, SWAGGER_API_URL]
+    # # 项目端口号
+    # PORT: int = 8080
+    #
+    # 应用运行根路径
+    # APPLICATION_PATH: str = f"{os.path.abspath(os.path.dirname(sys.argv[0]))}"
+    # # 静态资源目录
+    STATIC_PATH: str = f"{os.path.abspath(os.path.dirname(sys.argv[0]))}"
+    #
+    # # 是否启动资源注册
+    # RMS_REGISTER_ENABLE: bool = False
+    # # 注册地址
+    # RMS_REGISTER_SERVER: str = "http://127.0.0.1:8918"
+    #
+
+    # redis缓存开关
+    CACHE_ENABLE: bool = False
+    REDIS_CACHE_KEY = "redis"
+    REDIS_OAUTH_KEY = None
+    #
+    # # 外网地址
+    # OUTSIDE_SCREEN_IP: str = ""
+    # # 内网ip
+    # INSTANCE_IP: str = ""
+    #
+    # 数据服务
+    CAPABILITY_PLATFORM_SERVER: str = "http://127.0.0.1:8976"
+    # # 权限服务地址
+    # OAUTH_SERVER: str = ""
+    # # 后端管理地址
+    # UPMS_SERVER: str = ""
+    # # 报告服务地址
+    # REPORT_SERVER: str = ""
+    #
+    # # aes加密key
+    # AES_KEY: str = 'haohaoxuexi'
+    # ks3连接配置
+    # host ks3的地址; access_key_id ks3的key; access_key_secret ks3的密钥 is_secure 是否使用https协议
+    KS3_CONNECT_CONFIG: dict = {"bucket_name": "", "host": "", "access_key_id": "", "access_key_secret": "",
+                                "is_secure": False}
+    # request请求的参数
+    CONNECT_CONFIG: dict = {
+        # "pool_connections": 10,
+        # "pool_maxsize": 100,
+        # "max_retries": 1,
+        # "pool_block": False
+    }
+    #
+    # # mysql ip地址
+    # MYSQL_IP: str = ""
+    # # mysql 端口号
+    # MYSQL_PORT: str = ""
+    # # mysql 用户名
+    # MYSQL_USERNAME: str = ""
+    # # mysql 用户密码
+    # MYSQL_PASSWORD: str = ""
+    #
+    # # clickhouse ip地址
+    # CK_IP: str = ""
+    # # clickhouse 端口号
+    # CK_PORT: str = ""
+    # # clickhouse 用户名
+    # CK_USERNAME: str = ""
+    # # clickhouse 密码
+    # CK_PASSWORD: str = ""
+
+    # swagger 的名称
+    SWAGGER_NAME = "API"
+    # swagger 的版本
+    SWAGGER_VERSION = "1.0.0"
+    # swagger 的描述
+    SWAGGER_DESCRIPTION = "项目接口说明文档"

lesscode_flask/setup/__init__.py

@@ -0,0 +1,185 @@
+import importlib
+from logging.handlers import TimedRotatingFileHandler
+
+import redis
+from flask import current_app
+from flask_login import LoginManager
+from flask_swagger_ui import get_swaggerui_blueprint
+
+from lesscode_flask.db import db
+from lesscode_flask.log.access_log_handler import AccessLogHandler
+from lesscode_flask.model.user import AnonymousUser, User
+from lesscode_flask.service.authentication_service import get_token_user, get_api_user
+from lesscode_flask.utils.swagger.swagger_util import generate_openapi_spec
+
+
+def setup_logging(app):
+    """
+    初始化日志配置
+    1. 日志等级
+        DEBUG : 10
+        INFO：20
+        WARN：30
+        ERROR：40
+        CRITICAL：50
+    :return:
+    """
+    import logging
+    import sys
+    # 日志配置
+    # 日志级别
+    LOG_LEVEL = app.config.get("LESSCODE_LOG_LEVEL", "DEBUG")
+    # 日志格式
+    LOG_FORMAT = app.config.get("LESSCODE_LOG_FORMAT",
+                                '[%(asctime)s] [%(levelname)s] [%(name)s:%(module)s:%(lineno)d] [%(message)s]')
+    # 输出管道
+    LOG_STDOUT = app.config.get("LESSCODE_LOG_STDOUT", True)
+    # 日志文件备份数量
+    LOG_FILE_BACKUPCOUNT = app.config.get("LESSCODE_LOG_FILE_BACKUPCOUNT", 7)
+    # 日志文件分割周期
+    LOG_FILE_WHEN = app.config.get("LESSCODE_LOG_LOG_FILE_WHEN", "D")
+    # 日志文件存储路径
+    LOG_FILE_PATH = app.config.get("LESSCODE_LOG_FILE_PATH", 'logs/lesscode.log')
+    formatter = logging.Formatter(LOG_FORMAT, datefmt='%Y-%m-%d %H:%M:%S')
+    logging.getLogger().setLevel(LOG_LEVEL.upper())
+    # 控制台输出
+    console_handler = logging.StreamHandler(sys.stdout if LOG_STDOUT else sys.stderr)
+    console_handler.setFormatter(formatter)
+    file_handler = logging.handlers.TimedRotatingFileHandler(LOG_FILE_PATH, when=LOG_FILE_WHEN,
+                                                             backupCount=LOG_FILE_BACKUPCOUNT)
+
+    file_handler.setFormatter(formatter)
+    logging.getLogger().addHandler(console_handler)
+    logging.getLogger().addHandler(file_handler)
+    logging.addLevelName(100, 'ACCESS')
+
+    LESSCODE_ACCESS_LOG_DB = app.config.get("LESSCODE_ACCESS_LOG_DB", 0)
+    if LESSCODE_ACCESS_LOG_DB == 1:
+        access_log_handler = AccessLogHandler()
+        access_log_handler.level = 100
+        logging.getLogger().addHandler(access_log_handler)
+
+
+def setup_blueprint(app, path=None, pkg_name="handlers"):
+    import os
+    from flask import Blueprint
+    import inspect
+    """
+    动态注册Handler模块
+    遍历项目指定包内的Handler，将包内module引入。
+    :param path: 项目内Handler的文件路径
+    :param pkg_name: 引入模块前缀
+    """
+    if path is None:
+        # 项目内Handler的文件路径，使用当前工作目录作为根
+        path = os.path.join(os.getcwd(), pkg_name)
+    # 首先获取当前目录所有文件及文件夹
+    dynamic_handler_names = os.listdir(path)
+    for handler_name in dynamic_handler_names:
+        # 利用os.path.join()方法获取完整路径
+        full_file = os.path.join(path, handler_name)
+        # 循环判断每个元素是文件夹还是文件
+        if os.path.isdir(full_file) and handler_name != "__pycache__":
+            # 文件夹递归遍历
+            setup_blueprint(app, os.path.join(path, handler_name), ".".join([pkg_name, handler_name]))
+        elif os.path.isfile(full_file) and handler_name.lower().endswith("handler.py"):
+            # 文件，并且为handler结尾，认为是请求处理器，完成动态装载
+            module_path = "{}.{}".format(pkg_name, handler_name.replace(".py", ""))
+            module = importlib.import_module(module_path)  # __import__(module_path)
+            for name, obj in inspect.getmembers(module):
+                # 找到Blueprint 的属性进行注册
+                if isinstance(obj, Blueprint):
+                    # 如果有配置统一前缀则作为蓝图路径的统一前缀
+                    if hasattr(obj, "url_prefix") and app.config.get("ROUTE_PREFIX", ""):
+                        obj.url_prefix = f'{app.config.get("ROUTE_PREFIX")}{obj.url_prefix}'
+                    # 加载完成后 注册蓝图到应用
+                    app.register_blueprint(obj)
+
+
+def setup_query_runner():
+    """
+    注入数据查询执行器
+    :return:
+    """
+    from redash.query_runner import import_query_runners
+    from redash import settings as redash_settings
+    import_query_runners(redash_settings.QUERY_RUNNERS)
+
+
+def setup_sql_alchemy(app):
+    """
+    配置SQLAlchemy
+    :param app:
+    :return:
+    """
+    db.init_app(app)
+
+
+def setup_login_manager(app):
+    login_manager = LoginManager(app)
+    setattr(app, "login_manager", login_manager)
+
+    @login_manager.request_loader
+    def request_loader(request):
+        # # 使用token访问的用户
+        token = request.headers.get("Authorization", "").replace("Bearer ", "")
+        if token:
+            user = get_token_user(token)
+            if user:
+                return user
+        apikey = request.headers.get("API-Key")
+        if apikey:
+            # 使用AK访问的接口用户
+            user = get_api_user(apikey)
+            if user:
+                return user
+        # 无任何用户信息返回 匿名用户
+        return AnonymousUser()
+
+
+def setup_swagger(app):
+    """
+    配置Swagger
+    :param app:
+    :return:
+    """
+    SWAGGER_URL = app.config.get("SWAGGER_URL", "")  # 访问 Swagger UI 的 URL
+    # API_URL = 'http://127.0.0.1:5001/static/swagger.json'  # Swagger 规范的路径（本地 JSON 文件）
+    API_URL = app.config.get("SWAGGER_API_URL", "")  # 接口
+    # 创建 Swagger UI 蓝图
+    swagger_ui_blueprint = get_swaggerui_blueprint(
+        SWAGGER_URL,  # Swagger UI 访问路径
+        app.config.get("OUTSIDE_SCREEN_IP") + API_URL,  # Swagger 文件路径
+        config={  # Swagger UI 配置参数
+            'app_name': "Flask-Swagger-UI 示例"
+        }
+    )
+    app.register_blueprint(swagger_ui_blueprint, url_prefix=SWAGGER_URL)
+
+    @app.route(API_URL, methods=['GET'])
+    def swagger_spec():
+        from lesscode_flask import __version__
+        swag = generate_openapi_spec(app)
+        swag['info']['title'] = app.config.get("SWAGGER_NAME", "")
+        swag['info']['description'] = app.config.get("SWAGGER_DESCRIPTION", "")
+        swag['info']['version'] = app.config.get("SWAGGER_VERSION", __version__)
+        return swag
+
+
+def setup_redis(app):
+    redis_conn_list = app.config.get("DATA_SOURCE", [])
+
+    for r in redis_conn_list:
+        if r.get("type") == "redis":
+            conn = redis.Redis(host=r.get("host"), port=r.get("port"), db=r.get("db"), password=r.get("password"),
+                               decode_responses=True)
+            if not hasattr(current_app, "redis_conn_dict"):
+                current_app.redis_conn_dict = {}
+            if getattr(current_app, "redis_conn_dict").get(r.get("conn_name")):
+                raise Exception("Connection {} is repetitive".format(r.get("conn_name")))
+            else:
+                redis_conn_dict = getattr(current_app, "redis_conn_dict")
+                redis_conn_dict.update({
+                    r.get("conn_name"): conn
+                })
+                setattr(current_app, "redis_conn_dict", redis_conn_dict)

lesscode_flask/utils/__init__.py

@@ -0,0 +1 @@
+

lesscode_flask/utils/decorator/cache.py

@@ -0,0 +1,126 @@
+import copy
+import datetime
+import functools
+import inspect
+import json
+import logging
+import sys
+import traceback
+
+from threading import Thread
+
+# 装饰器
+from lesscode_utils.json_utils import JSONEncoder
+
+from lesscode_flask.utils.helpers import app_config
+from lesscode_flask.utils.redis.redis_helper import RedisHelper
+
+
+def Cache(ex=3600 * 12, cache_key=None):
+    def cache_func(func):
+        # 默认key生成方法：str(item)
+        @functools.wraps(func)
+        def cache_wrapper(*args, **params):
+            try:
+                data = deal_cache(func, ex, cache_key, *args, **params)
+            except Exception as e:
+                logging.error(traceback.format_exc())
+                data = func(*args, **params)
+            return data
+
+        return cache_wrapper
+
+    return cache_func
+
+
+def deal_cache(func, ex, cache_key, *args, **params):
+    # 获取缓存查询key
+    signature = inspect.signature(func)
+    params = dict(sorted(params.items(), key=lambda x: x[0]))
+    func_name = str(func).split(" ")[1]
+    if not cache_key:
+        cache_key = format_insert_key(signature, func_name, args, params)
+    logging.info("redis_key:{}".format(cache_key))
+    value = query_cache(cache_key, params, ex, func=func, args=args)
+    if value is not False:
+        data = value
+    else:
+        start = datetime.datetime.now()
+        logging.info("[组件：{}]数据开始计算！".format(func_name))
+        # copy_params = copy.deepcopy(params)
+        # data = func(*args, **copy_params)
+        data = func(*args, **params)
+        # 插入缓存表
+        insert_cache(data, ex, cache_key)
+        logging.info("[组件：{}]数据缓存已刷新！用时{}".format(func_name, datetime.datetime.now() - start))
+
+    return data
+
+
+def get_redis_conn_name():
+    try:
+        conn_name = app_config.get("REDIS_CACHE_KEY", "redis")
+    except:
+        raise Exception("Redis connection is missing")
+    return conn_name
+
+
+def query_cache(cache_key, params=None, ex=3600 * 12, func=None, args=None, conn_name=None):
+    if conn_name is None:
+        conn_name = get_redis_conn_name()
+
+    if app_config.get("CACHE_ENABLE"):
+        ttl = RedisHelper(conn_name).get_connection().ttl(cache_key)
+
+        if ttl and ex >= 900 and 0 < ttl <= ex - 900:
+            Thread(target=request_interface, kwargs={
+                "func": func,
+                "params": params,
+                "args": args,
+                "ex": ex,
+                "cache_key": cache_key
+            }).start()
+        data = RedisHelper(conn_name).sync_get(cache_key)
+        if data:
+            value = json.loads(data)
+            return value
+        else:
+            logging.info("str_select_key为".format(cache_key))
+            return False
+    return False
+
+
+def request_interface(func, params, args, ex, cache_key):
+    # copy_params = copy.deepcopy(params)
+    data = func(*args, **params)
+    insert_cache(data, ex, cache_key)
+
+
+def format_insert_key(signature, func_name, args, params):
+    _args = []
+    param_keys = list(signature.parameters.keys())
+    if param_keys and args:
+        if param_keys[0] == "self":
+            _args = copy.deepcopy(args[1:])
+        else:
+            _args = copy.deepcopy(args)
+    if isinstance(_args, tuple):
+        _args = list(_args)
+    for k in params:
+        if k != "self":
+            _args.append(json.dumps(params[k]))
+    str_insert_key = "&".join([str(x) for x in _args])
+    str_insert_key = app_config.get("ROUTE_PREFIX") + "#" + func_name + "#" + str_insert_key
+    return str_insert_key
+
+
+def insert_cache(data, ex, cache_key, conn_name=None):
+    # 大于512kb不缓存
+    if sys.getsizeof(data) <= 512 * 1024:
+        if conn_name is None:
+            conn_name = get_redis_conn_name()
+        if app_config.get("CACHE_ENABLE"):
+            try:
+                RedisHelper(conn_name).sync_set(cache_key, JSONEncoder().encode(data), ex=ex)
+            except:
+                logging.error(traceback.format_exc())

lesscode_flask/utils/decorator/swagger.py

@@ -0,0 +1,19 @@
+# 装饰器来标识请求类型
+from functools import wraps
+
+
+def request_type(content_type="json"):
+    """
+    :param content_type: form-data,json,urlencoded
+    :return:
+    """
+
+    def decorator(f):
+        @wraps(f)
+        def decorated_function(*args, **kwargs):
+            return f(*args, **kwargs)
+
+        decorated_function._request_type = content_type
+        return decorated_function
+
+    return decorator

lesscode_flask/utils/file/file_exporter.py

@@ -0,0 +1,98 @@
+import importlib
+import os
+import uuid
+from urllib.parse import quote
+
+from flask import send_file
+
+from lesscode_flask.setting import BaseConfig
+from lesscode_flask.utils.helpers import app_config
+from lesscode_flask.utils.oss.ks3_oss import Ks3Oss
+
+
+def judge_file_name(parent_path, file_name, extension, index=1):
+    while os.path.isfile(f'{parent_path}/{file_name}.{extension}'):
+        if index > 1:
+            file_name = file_name.replace(f'({index - 1})', f'({index})')
+        else:
+            file_name = f'{file_name}({index})'
+
+        index = index + 1
+    return f'{parent_path}/{file_name}.{extension}', f'{file_name}.{extension}'
+
+
+def format_to_table_download(table_head_list=None, table_body_list=None):
+    data_index_list = [one['dataIndex'] for one in table_head_list]
+    table_head_map_dict = {one['dataIndex']: one['title'] for one in table_head_list}
+    sta_map_dict = {}
+    for one in table_body_list:
+        for tag in data_index_list:
+            if tag not in sta_map_dict:
+                sta_map_dict[tag] = [one[tag]]
+            else:
+                sta_map_dict[tag].append(one[tag])
+    sta_map_dict = {table_head_map_dict[k]: v for k, v in sta_map_dict.items()}
+    return sta_map_dict
+
+
+def export(table_head_list=None, table_body_list=None, file_name=None, extension="xlsx", export_path=None,
+           is_upload_ks3=False, bucket_name=None):
+    """
+    :param is_upload_ks3: 是否上传至ks3
+    :param table_head_list: [
+            {
+                "title": "企业名称",
+                "dataIndex": "name"
+            },
+            {
+                "title": "省",
+                "dataIndex": "reg_province"
+            }
+        ]
+    :param table_body_list: [
+            {
+                 "name":"丽丽"
+                 "reg_province":"北京市"
+            }
+
+    ]
+    :param file_name:导出文件的名称
+    :param extension:扩展名
+    :param export_path: 导出目录 默认是静态目录下的download
+    :return:
+    """
+    data = format_to_table_download(table_head_list, table_body_list)
+    try:
+        pandas = importlib.import_module("pandas")
+    except ImportError:
+        raise Exception(f"pandas is not exist,run:pip install pandas==2.2.2")
+
+    df = pandas.DataFrame(data=data)
+    # 定义下载目录，如果没有就新建
+    if not export_path:
+        export_path = f'{BaseConfig.STATIC_PATH}/download'
+    if not os.path.exists(export_path):
+        os.mkdir(export_path)
+    # 判断文件的名称如果存在则加(n)
+    file_path, file_name = judge_file_name(export_path, file_name, extension)
+
+    df.to_excel(file_path, index=False)
+
+    file_name = quote(file_name)
+
+    if is_upload_ks3:
+        ks = Ks3Oss()
+        if not bucket_name:
+            bucket_name = app_config.get("KS3_CONNECT_CONFIG", {}).get("bucket_name")
+        response = ks.save(key=file_name, bucket_name=bucket_name, policy="public-read", filename=file_path,
+                           content_type="filename")
+    else:
+        response = send_file(
+            file_path,
+            mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+            as_attachment=False,
+            download_name=file_name
+        )
+    # 下载完成删除文件
+    os.remove(file_path)
+    return response

lesscode_flask/utils/helpers.py

@@ -0,0 +1,139 @@
+class app_config:
+
+    @staticmethod
+    def get(key, default=None):
+        """
+        获取配置
+        :param key: 配置key
+        :param default: 默认值
+        :return:
+        """
+        from flask import current_app
+        return current_app.config.get(key, default)
+
+
+def serialize_result_to_dict(result):
+    """
+    结果对象序列化为字典
+    :param result:
+    :return:
+    """
+    if isinstance(result, list):
+        return [serialize_result_to_dict(r) for r in result]
+    if not hasattr(result, "__dict__"):
+        return result
+    return {k: v for k, v in result.__dict__.items() if not k.startswith('_')}
+
+
+def generate_uuid():
+    """
+    生成UUID
+    :return:
+    """
+    import uuid
+    return uuid.uuid4().hex.replace("-", "")
+
+
+def get_start_port():
+    """
+    获取启动端口
+    :return:
+    """
+    import sys
+    arg_list = sys.argv
+    for a in arg_list:
+        if "--port" in a:
+            return a.split("=")[1]
+    return "5000"
+
+
+def parameter_validation(obj: dict):
+    """
+    验证参数对象中非None的键值
+    :return:
+    """
+    return {k: v for k, v in obj.items() if v}
+
+
+def parse_boolean(s):
+    """
+    将字符串转换为布尔值。
+    :param s: 待转换的字符串
+    :return:
+    """
+    s = s.strip().lower()
+    if s in ("yes", "true", "on", "1"):
+        return True
+    # elif s in ("no", "false", "off", "0", "none"):
+    #     return False
+    else:
+        # 其余不在判断全返False
+        return False
+
+
+def inject_args(req, func, view_args={}):
+    import inspect
+
+    """
+    实现参数自动注入
+    :param req: 请求对象
+    :param func: 请求处理函数
+    :param view_args: 路径上获取的参数
+    :return:
+    """
+    jsons = {}
+    args = req.args
+    form = req.form
+    files = req.files
+    if req.mimetype == 'application/json' and req.json is not None:
+        jsons = req.json
+    # 合并args、form和json参数字典
+    arguments = dict(**args, **form, **jsons, **files, **view_args)
+    # 获取处理方法的 参数签名
+    parameters = inspect.signature(func).parameters.items()
+    # 获取所有参数名称
+    parameter_names = [parameter_name for parameter_name, parameter in parameters]
+    kwargs = {}
+    # 检查传入的参数中 哪些不在参数列表中，单独存储
+    for key in arguments.keys():
+        if key not in parameter_names:
+            kwargs[key] = arguments[key]
+    params_dict = {}
+    # parameterName 参数名称, parameter 参数对象
+    for parameter_name, parameter in parameters:
+        # 依据参数名称，获取请求参数值
+        argument_value = arguments.get(parameter_name)
+        # 兼容**kwargs 参数
+        if parameter.kind == inspect.Parameter.VAR_KEYWORD:
+            argument_value = kwargs
+        if argument_value:
+            # 获取形参类型
+            parameter_type = parameter.annotation
+            # 形参类型为空，尝试获取形参默认值类型
+            if parameter_type is inspect.Parameter.empty:
+                parameter_type = type(parameter.default)
+            if parameter_type == int:
+                params_dict[parameter_name] = int(argument_value)
+            elif parameter_type == float:
+                params_dict[parameter_name] = float(argument_value)
+            elif parameter_type == bool:
+                params_dict[parameter_name] = parse_boolean(argument_value)
+            else:
+                # 其余都按str处理
+                params_dict[parameter_name] = argument_value
+    return params_dict
+
+
+def mustache_render(template, **kwargs):
+    """
+    模板参数渲染
+    :param template: 模板
+    :param kwargs:参数
+    :return:
+    """
+    from jinja2 import Template
+    # 创建模板对象
+    template = Template(template)
+    # 渲染模板
+    return template.render(**kwargs)
+