xtn-tools-pro 1.0.0.0.4__py3-none-any.whl → 1.0.0.0.6__py3-none-any.whl

xtn_tools_pro/utils/helpers.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# 说明：
+#    杂七杂八
+# History:
+# Date          Author    Version       Modification
+# --------------------------------------------------------------------------------------------------
+# 2024/5/13    xiatn     V00.01.000    新建
+# --------------------------------------------------------------------------------------------------
+import re
+import uuid
+import math
+import json
+from uuid import UUID
+from pprint import pformat
+from urllib.parse import urlencode
+
+
+def get_uuid(version=4, namespace: UUID = uuid.NAMESPACE_DNS, name=""):
+    """
+        生成uuid
+    :param version:版本号
+        1:基于当前时间和 MAC 地址生成版本 1 的 UUID，具有唯一性，但可能存在一定的安全风险。
+        3:基于名称和命名空间的方式生成。它通过将名称和命名空间的标识符组合起来进行哈希计算，生成一个唯一的标识符。UUID 版本 3 使用的哈希算法是 MD5。
+        4:使用随机数生成版本 4 的 UUID，具有足够的随机性和唯一性。
+        5:使用基于命名空间和名称生成版本 5 的 UUID，可以使用自定义的命名空间和名称。
+    :param namespace:命名空间 uuid.NAMESPACE_DNS、uuid.NAMESPACE_URL、uuid.NAMESPACE_OID、uuid.NAMESPACE_X500
+    :param name:名称 自定义
+    :return:
+    """
+    if version == 1:
+        result = uuid.uuid1()
+    elif version == 3:
+        result = uuid.uuid3(namespace, name)
+    elif version == 5:
+        result = uuid.uuid5(namespace, name)
+    else:
+        result = uuid.uuid4()
+
+    uuid_str = str(result)
+    # uuid_hex = uuid_obj.hex
+    # uuid_int = uuid_obj.int
+    # uuid_bytes = uuid_obj.bytes
+    return uuid_str
+
+
+def get_str_to_json(str_json):
+    """
+        字符串类型的json格式 转 json
+    :param str_json: 字符串json
+    :return:
+    """
+    try:
+        new_str_json = str_json.replace("'", '"'). \
+            replace("None", "null").replace("True", "true"). \
+            replace("False", "false")
+        return json.loads(new_str_json)
+    except Exception as e:
+        return {}
+
+
+def list_to_strtuple(datas):
+    """
+        列表转字符串元组
+    :param datas: datas: [1, 2]
+    :return: (1, 2) 字符串类型
+    """
+    data_str = str(tuple(datas))
+    data_str = re.sub(",\)$", ")", data_str)
+    return data_str
+
+
+def dumps_json(data, indent=4, sort_keys=False):
+    """
+        将JSON数据格式化为可打印的字符串
+    :param data:
+    :param indent: 每一级嵌套都使用4个空格进行缩进
+    :param sort_keys: 是否排序
+    :return:
+    """
+    try:
+        if isinstance(data, str):
+            data = get_str_to_json(data)
+
+        data = json.dumps(
+            data,
+            ensure_ascii=False,
+            indent=indent,
+            skipkeys=True,
+            sort_keys=sort_keys,
+            default=str,
+        )
+
+    except Exception as e:
+        data = pformat(data)
+
+    return data
+
+
+def get_calculate_total_page(total, limit):
+    """
+        根据total和limit计算出一共有多少页
+    :param total:
+    :param limit:
+    :return:
+    """
+    if limit <= 0:
+        return 0
+    # 根据总条数和limit计算总页数
+    total_pages = math.ceil(total / limit)
+    return total_pages
+
+def get_build_url_with_params(url, params):
+    """
+        传入url和params拼接完整的url ->效果 https://wwww.xxxx.com/?xxx1=1&xxx2=2
+    :param url:
+    :param params:
+    :return:
+    """
+    encoded_params = urlencode(params)
+    full_url = url + "?" + encoded_params
+    return full_url

xtn_tools_pro/utils/log.py

@@ -0,0 +1,192 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# 说明：
+#    日志
+# History:
+# Date          Author    Version       Modification
+# --------------------------------------------------------------------------------------------------
+# 2024/5/12     xiatn     V00.01.000    新建
+# --------------------------------------------------------------------------------------------------
+import os
+import sys
+import inspect
+import logging
+from logging.handlers import BaseRotatingHandler
+from xtn_tools_pro.utils.time_utils import get_time_timestamp_to_datestr
+
+
+class RotatingFileHandler(BaseRotatingHandler):
+    def __init__(
+            self, filename, mode="a", max_bytes=0, backup_count=0, encoding=None, delay=0
+    ):
+        BaseRotatingHandler.__init__(self, filename, mode, encoding, delay)
+        self.max_bytes = max_bytes
+        self.backup_count = backup_count
+        self.placeholder = str(len(str(backup_count)))
+
+    def doRollover(self):
+        if self.stream:
+            self.stream.close()
+            self.stream = None
+        if self.backup_count > 0:
+            for i in range(self.backup_count - 1, 0, -1):
+                sfn = ("%0" + self.placeholder + "d.") % i  # '%2d.'%i -> 02
+                sfn = sfn.join(self.baseFilename.split("."))
+                # sfn = "%d_%s" % (i, self.baseFilename)
+                # dfn = "%d_%s" % (i + 1, self.baseFilename)
+                dfn = ("%0" + self.placeholder + "d.") % (i + 1)
+                dfn = dfn.join(self.baseFilename.split("."))
+                if os.path.exists(sfn):
+                    # print "%s -> %s" % (sfn, dfn)
+                    if os.path.exists(dfn):
+                        os.remove(dfn)
+                    os.rename(sfn, dfn)
+            dfn = (("%0" + self.placeholder + "d.") % 1).join(
+                self.baseFilename.split(".")
+            )
+            if os.path.exists(dfn):
+                os.remove(dfn)
+            # Issue 18940: A file may not have been created if delay is True.
+            if os.path.exists(self.baseFilename):
+                os.rename(self.baseFilename, dfn)
+        if not self.delay:
+            self.stream = self._open()
+
+    def shouldRollover(self, record):
+
+        if self.stream is None:  # delay was set...
+            self.stream = self._open()
+        if self.max_bytes > 0:  # are we rolling over?
+            msg = "%s\n" % self.format(record)
+            self.stream.seek(0, 2)  # due to non-posix-compliant Windows feature
+            if self.stream.tell() + len(msg) >= self.max_bytes:
+                return 1
+        return 0
+
+
+class BoldFormatter(logging.Formatter):
+    def format(self, record):
+        result = super().format(record)
+        return "\033[1m" + result + "\033[0m"
+
+
+class Log:
+    def __init__(self, name, path=None, log_level='DEBUG',
+                 is_write_to_console=True,
+                 is_write_to_file=False,
+                 color=True,
+                 mode='a',
+                 max_bytes=0, backup_count=0, encoding=None):
+        """
+        :param name: log名
+        :param path: log文件存储路径 如 D://xxx.log
+        :param log_level: log等级 CRITICAL/ERROR/WARNING/INFO/DEBUG
+        :param is_write_to_console: 是否输出到控制台
+        :param is_write_to_file: 是否写入到文件 默认否
+        :param color: 是否有颜色
+        :param mode: 写文件模式
+        :param max_bytes: 每个日志文件的最大字节数
+        :param backup_count: 日志文件保留数量
+        :param encoding: 日志文件编码
+
+        """
+        # 创建logger对象
+        self.logger = logging.getLogger(name)
+        # 设置日志等级
+        self.logger.setLevel(log_level.upper())
+
+        # 创建日志格式化器
+        # formatter = logging.Formatter('[%(now_datestr)s] [%(levelname)s] [%(func_name)s] - %(message)s') # 原
+        # formatter = logging.Formatter('\033[1m%(now_datestr)s] [%(levelname)s] [%(func_name)s] - %(message)s\033[0m') #加粗
+        formatter = logging.Formatter(
+            '\033[1m[%(now_datestr)s] | %(levelname)-8s | [%(func_name)s] - %(message)s\033[0m')  # 加粗对齐
+
+        # formatter = BoldFormatter('[%(now_datestr)s] [%(levelname)s] [%(func_name)s] - %(message)s') # 加粗
+
+        # 判断是否要输出到控制台
+        if is_write_to_console:
+            # 创建控制台处理器
+            console_handler = logging.StreamHandler(sys.stdout)
+            # 设置控制台处理器的格式化器
+            console_handler.setFormatter(formatter)
+            # 将控制台处理器添加到logger中
+            self.logger.addHandler(console_handler)
+
+        # 判断是否要写入文件
+        if is_write_to_file:
+            # 创建文件处理器
+            file_handler = RotatingFileHandler(path, mode=mode, max_bytes=max_bytes,
+                                               backup_count=backup_count, encoding=encoding)
+            # 设置文件处理器的格式化器
+            file_handler.setFormatter(formatter)
+            # 将文件处理器添加到logger中
+            self.logger.addHandler(file_handler)
+
+        # 判断是否要带颜色
+        if color:
+            try:
+                from colorlog import ColoredFormatter
+                # 创建带颜色的日志格式化器
+                # color_formatter = ColoredFormatter('%(log_color)s[%(now_datestr)s] [%(levelname)s] [%(func_name)s] - %(message)s') # 原
+                # color_formatter = ColoredFormatter('\033[1m%(log_color)s[%(now_datestr)s] [%(levelname)s] [%(func_name)s] - %(message)s\033[0m') # 加粗
+                # 创建颜色映射
+                log_colors = {
+                    'DEBUG': 'bold_blue',
+                    'INFO': 'bold_cyan',
+                    'WARNING': 'bold_yellow',
+                    'ERROR': 'bold_red',
+                    'CRITICAL': 'bold_red',
+                }
+                color_formatter = ColoredFormatter(
+                    '\033[1m%(log_color)s[%(now_datestr)s] | %(levelname)-8s | [%(func_name)s] - %(message)s\033[0m',
+                    log_colors=log_colors)  # 加粗对齐
+                # 设置控制台处理器的格式化器为带颜色的格式化器
+                console_handler.setFormatter(color_formatter)
+            except ImportError:
+                pass
+
+    def debug(self, message):
+        # 记录DEBUG级别的日志
+        self.logger.debug(message, extra=self._get_caller_name_extra())
+
+    def info(self, message):
+        # 记录INFO级别的日志
+        self.logger.info(message, extra=self._get_caller_name_extra())
+
+    def warning(self, message):
+        # 记录WARNING级别的日志
+        self.logger.warning(message, extra=self._get_caller_name_extra())
+
+    def error(self, message):
+        # 记录ERROR级别的日志
+        self.logger.error(message, extra=self._get_caller_name_extra())
+
+    def critical(self, message):
+        # 记录CRITICAL级别的日志
+        self.logger.critical(message, extra=self._get_caller_name_extra())
+
+    def _get_caller_name_extra(self):
+        """
+            获取调用日志函数的函数名称
+        """
+        # 获取当前栈帧
+        frame = inspect.currentframe()
+        # 获取调用者的栈帧
+        caller_frame = frame.f_back.f_back
+        # 从栈帧中获取代码对象
+        code_obj = caller_frame.f_code
+        # 获取调用者的名字
+        caller_name = code_obj.co_name
+        return {"func_name": caller_name,
+                "now_datestr": get_time_timestamp_to_datestr()}
+
+
+if __name__ == '__main__':
+    pass
+    logger = Log('mylogger', './xxx.log', log_level='DEBUG', is_write_to_console=True, is_write_to_file=True,
+                 color=True, mode='a', max_bytes=1024, backup_count=3)
+    logger.debug("debug message")
+    logger.info("info level message")
+    logger.warning("warning level message")
+    logger.critical("critical level message")

xtn_tools_pro/utils/retry.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# 说明：
+#    重试
+# History:
+# Date          Author    Version       Modification
+# --------------------------------------------------------------------------------------------------
+# 2024/5/12    xiatn     V00.01.000    新建
+# --------------------------------------------------------------------------------------------------
+import time
+from xtn_tools_pro.utils.log import Log
+
+log = Log(name="retry", color=True)
+
+
+def retry(max_attempts=3, delay=0, exception_callfunc=None, *args_callfunc, **kwargs_callfunc):
+    """
+        重试
+    :param max_attempts: 最多重试次数
+    :param delay: 每次重试间隔时间
+    :param exception_callfunc: 失败的回调函数
+    :return:
+    """
+
+    def decorator(func):
+        def wrapper(*args, **kwargs):
+            attempts = 0
+            while attempts < max_attempts:
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    log.debug(f"重试第 {attempts + 1} 次,failed: {e}")
+                    if exception_callfunc:
+                        exception_callfunc(*args_callfunc, **kwargs_callfunc)
+                    attempts += 1
+                    time.sleep(delay)
+
+        return wrapper
+
+    return decorator
+
+
+if __name__ == '__main__':
+
+    def test1(*args, **kwargs):
+        print("test1", args, kwargs)
+
+
+    @retry(3, 5)
+    def test(a, b):
+        import random
+        if random.random() < 0.5:
+            raise ValueError("Random value too small")
+        print("Success!")
+
+    test(1, 1)

xtn_tools_pro/utils/sql.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# 说明：
+#    sql相关
+# History:
+# Date          Author    Version       Modification
+# --------------------------------------------------------------------------------------------------
+# 2024/5/12    xiatn     V00.01.000    新建
+# --------------------------------------------------------------------------------------------------
+import datetime
+from xtn_tools_pro.utils.helpers import list_to_strtuple, dumps_json
+
+
+def format_sql_value(value):
+    if isinstance(value, str):
+        value = value.strip()
+
+    elif isinstance(value, (list, dict)):
+        value = dumps_json(value, indent=None)
+
+    elif isinstance(value, (datetime.date, datetime.time)):
+        value = str(value)
+
+    elif isinstance(value, bool):
+        value = int(value)
+
+    return value
+
+
+def get_insert_sql(table, data, auto_update=False, update_columns=(), insert_ignore=False):
+    """
+        生成 insert sql
+    :param table: 表
+    :param data: 表数据 json格式
+    :param auto_update: 使用的是replace into， 为完全覆盖已存在的数据
+    :param update_columns: 需要更新的列 默认全部，当指定值时，auto_update设置无效，当duplicate key冲突时更新指定的列
+    :param insert_ignore: 数据存在忽略，True则会忽略该插入操作，不会产生冲突错误
+    :return:
+    """
+    keys = ["`{}`".format(key) for key in data.keys()]
+    keys = list_to_strtuple(keys).replace("'", "")
+    values = [format_sql_value(value) for value in data.values()]
+    values = list_to_strtuple(values)
+    if update_columns:
+        if not isinstance(update_columns, (tuple, list)):
+            update_columns = [update_columns]
+        update_columns_ = ", ".join(
+            ["{key}=values({key})".format(key=key) for key in update_columns]
+        )
+        sql = (
+                "insert%s into `{table}` {keys} values {values} on duplicate key update %s"
+                % (" ignore" if insert_ignore else "", update_columns_)
+        )
+
+    elif auto_update:
+        sql = "replace into `{table}` {keys} values {values}"
+    else:
+        sql = "insert%s into `{table}` {keys} values {values}" % (
+            " ignore" if insert_ignore else ""
+        )
+
+    sql = sql.format(table=table, keys=keys, values=values).replace("None", "null")
+    return sql
+
+def get_insert_batch_sql(table, datas, auto_update=False, update_columns=(), update_columns_value=()):
+    """
+        生成 批量 insert sql
+    :param table: 表
+    :param datas: 表数据 [{...}]
+    :param auto_update: 使用的是replace into， 为完全覆盖已存在的数据
+    :param update_columns: 需要更新的列 默认全部，当指定值时，auto_update设置无效，当duplicate key冲突时更新指定的列
+    :param update_columns_value: 需要更新的列的值 默认为datas里边对应的值, 注意 如果值为字符串类型 需要主动加单引号， 如 update_columns_value=("'test'",)
+    :return:
+    """
+    if not datas:
+        return
+    keys = list(set([key for data in datas for key in data]))
+    values_placeholder = ["%s"] * len(keys)
+
+    values = []
+    for data in datas:
+        value = []
+        for key in keys:
+            current_data = data.get(key)
+            current_data = format_sql_value(current_data)
+
+            value.append(current_data)
+
+        values.append(value)
+
+    keys = ["`{}`".format(key) for key in keys]
+    keys = list_to_strtuple(keys).replace("'", "")
+
+    values_placeholder = list_to_strtuple(values_placeholder).replace("'", "")
+
+    if update_columns:
+        if not isinstance(update_columns, (tuple, list)):
+            update_columns = [update_columns]
+        if update_columns_value:
+            update_columns_ = ", ".join(
+                [
+                    "`{key}`={value}".format(key=key, value=value)
+                    for key, value in zip(update_columns, update_columns_value)
+                ]
+            )
+        else:
+            update_columns_ = ", ".join(
+                ["`{key}`=values(`{key}`)".format(key=key) for key in update_columns]
+            )
+        sql = "insert into `{table}` {keys} values {values_placeholder} on duplicate key update {update_columns}".format(
+            table=table,
+            keys=keys,
+            values_placeholder=values_placeholder,
+            update_columns=update_columns_,
+        )
+    elif auto_update:
+        sql = "replace into `{table}` {keys} values {values_placeholder}".format(
+            table=table, keys=keys, values_placeholder=values_placeholder
+        )
+    else:
+        sql = "insert ignore into `{table}` {keys} values {values_placeholder}".format(
+            table=table, keys=keys, values_placeholder=values_placeholder
+        )
+
+    return sql, values
+
+def get_update_sql(table, data, condition):
+    """
+        生成更新sql
+    :param table: 表
+    :param data: 表数据 json格式
+    :param condition: where 条件
+    :return:
+    """
+    key_values = []
+
+    for key, value in data.items():
+        value = format_sql_value(value)
+        if isinstance(value, str):
+            key_values.append("`{}`={}".format(key, repr(value)))
+        elif value is None:
+            key_values.append("`{}`={}".format(key, "null"))
+        else:
+            key_values.append("`{}`={}".format(key, value))
+
+    key_values = ", ".join(key_values)
+
+    sql = "update `{table}` set {key_values} where {condition}"
+    sql = sql.format(table=table, key_values=key_values, condition=condition)
+    return sql
+
+if __name__ == '__main__':
+    print(get_insert_sql("user_copy1", {"id": 5, "nickname": "1212", "email": "121212", "auth": 2},insert_ignore=True))
+    print(get_insert_batch_sql("user_copy1", [{"id": 5, "nickname": "555", "email": "555", "auth": 1},
+                                              {"id": 6, "nickname": "666", "email": "666", "auth": 2},
+                                              {"id": 7, "nickname": "777", "email": "777", "auth": 1}],
+                               ))
+    print(get_update_sql("user_copy1",{"email":"123","status":4},"id=2"))

xtn_tools_pro/utils/time_utils.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+# 说明：
+#    时间
+# History:
+# Date          Author    Version       Modification
+# --------------------------------------------------------------------------------------------------
+# 2024/5/13    xiatn     V00.01.000    新建
+# --------------------------------------------------------------------------------------------------
+import time
+import datetime
+
+
+def get_time_now_timestamp(is_time_10=False, is_time_13=False):
+    """
+        获取当前时间戳
+    :param is_time_10: 是否需要处理为10位的时间戳，默认不处理
+    :param is_time_13: 是否需要处理为13位的时间戳，默认不处理
+    :return:
+    """
+
+    if is_time_10:
+        val = int(time.time())
+    elif is_time_13:
+        val = int(time.time() * 1000)
+    else:
+        val = time.time()
+    return val
+
+
+def get_time_now_day0_timestamp(is_time_13=False):
+    """
+        获取当天0点时间戳
+    :param is_time_13: 是否需要处理为13位的时间戳，默认不处理并且返回10位时间戳
+    :return:
+    """
+    val = time.mktime(datetime.date.today().timetuple())
+    if is_time_13:
+        return int(val * 1000)
+    else:
+        return int(val)
+
+
+def get_time_now_day59_timestamp(is_time_13=False):
+    """
+        获取当天23:59:59点时间戳
+    :param is_time_13: 是否需要处理为13位的时间戳，默认不处理并且返回10位时间戳
+    :return:
+    """
+    # 获取当前日期时间
+    now = datetime.datetime.now()
+    # 设置小时、分钟、秒为 23:59:59
+    last_second = now.replace(hour=23, minute=59, second=59)
+    # 转换为时间戳
+    timestamp = time.mktime(last_second.timetuple())
+    # 转换为整数类型
+    if is_time_13:
+        return get_time_10_to_13_timestamp(timestamp)
+    else:
+        return int(timestamp)
+
+
+def get_time_x_day_timestamp(x, is_time_13=False):
+    """
+        获取x天的0点的时间戳
+    :param x: 0:当天; 1:1天后; -1:一天前
+    :param is_time_13: 是否需要处理为13位的时间戳，默认不处理并且返回10位时间戳
+    :return:
+    """
+    if x == 0:
+        date_string = datetime.datetime.now().strftime("%Y-%m-%d")  # 当天日期
+    elif x > 0:
+        future_date = datetime.datetime.now() + datetime.timedelta(days=x)
+        date_string = future_date.strftime("%Y-%m-%d")  # x天后的日期
+    else:
+        past_date = datetime.datetime.now() - datetime.timedelta(days=abs(x))
+        date_string = past_date.strftime("%Y-%m-%d")  # x天前的日期
+
+    timestamp = get_time_datestr_to_timestamp(date_string=date_string, is_time_13=is_time_13)
+    return timestamp
+
+
+def get_time_datestr_to_timestamp(date_string, date_format="%Y-%m-%d", is_time_13=False):
+    """
+        根据日期格式转换为时间戳，date_string和date_format需要配合，自行传参修改，这里是以%Y-%m-%d为格式也就是2024-04-18
+    :param date_string: 字符串类型的日期格式 例如：2024-04-18
+    :param date_format: 时间格式
+    :param is_time_13: 是否需要处理为13位的时间戳，默认不处理并且返回10位时间戳
+    :return:
+    """
+    date_obj = datetime.datetime.strptime(date_string, date_format)
+    timestamp = date_obj.timestamp()
+    if is_time_13:
+        return get_time_10_to_13_timestamp(timestamp)
+    else:
+        return int(timestamp)
+
+
+def get_time_10_to_13_timestamp(timestamp):
+    """
+        10位时间戳转13位时间戳
+    :param timestamp:
+    :return:
+    """
+    val = int(timestamp)
+    if len(str(val)) == 10:
+        return int(val * 1000)
+    return val
+
+
+def get_time_13_to_10_timestamp(timestamp):
+    """
+        13位时间戳转10位时间戳
+    :param timestamp:
+    :return:
+    """
+    val = int(timestamp)
+    if len(str(val)) == 13:
+        return int(val // 1000)
+    return val
+
+
+def get_time_timestamp_to_datestr(format='%Y-%m-%d %H:%M:%S', now_time=0):
+    """
+        根据时间戳转换为日期格式，兼容10位时间戳和13位时间戳
+    :param format: 日期格式，常用：%Y-%m-%d %H:%M:%S、%Y-%m-%d、%Y/%m/%d、%H:%M:%S ...
+    :param now_time: 时间戳，默认0表示当前时间戳
+    :return:
+    """
+    # 根据格式获取当前转换好的时间
+    if not now_time:
+        now_time = get_time_now_timestamp()
+    now_time = get_time_13_to_10_timestamp(now_time)
+    val = time.strftime(format, time.localtime(now_time))
+    return val
+
+
+if __name__ == '__main__':
+    pass
+    print(get_time_timestamp_to_datestr())
+    print(get_time_timestamp_to_datestr(format="%H:%M:%S", now_time=get_time_now_timestamp(is_time_10=True)))
+    print(get_time_timestamp_to_datestr(now_time=get_time_now_timestamp(is_time_13=True)))

{xtn_tools_pro-1.0.0.0.4.dist-info → xtn_tools_pro-1.0.0.0.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xtn-tools-pro
-Version: 1.0.0.0.4
+Version: 1.0.0.0.6
 Summary: xtn 开发工具
 Author: xtn
 Author-email: czw011122@163.com
@@ -10,6 +10,9 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pymongo
 Requires-Dist: redis
+Requires-Dist: pymysql
+Requires-Dist: dbutils
+Requires-Dist: colorlog
 Requires-Dist: requests
 
 xtnkk-tools