re-common 10.0.40__tar.gz → 10.0.42__tar.gz

{re_common-10.0.40/re_common.egg-info → re_common-10.0.42}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.1
 Name: re_common
-Version: 10.0.40
+Version: 10.0.42
 Summary: a library about all python projects
 Home-page: https://gitee.com/xujiangios/re-common
 Author: vic
@@ -11,14 +11,6 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
-Dynamic: requires-python
-Dynamic: summary
 
 
     这是一个基础类，依赖很多的第三方包，是一个用得到的第三方库的封装，可以在此基础上迅速构建项目

{re_common-10.0.40 → re_common-10.0.42}/re_common/v2/baselibrary/business_utils/BusinessStringUtil.py

@@ -1,6 +1,9 @@
 # 某些业务中的字符串处理 算是特定场景的工具 不算通用工具
+import itertools
 import re
 
+from rapidfuzz.fuzz import partial_token_set_ratio
+
 from re_common.v2.baselibrary.utils.author_smi import AuthorRatio
 from re_common.v2.baselibrary.utils.string_bool import is_all_symbols
 from re_common.v2.baselibrary.utils.string_clear import rel_clear
@@ -199,7 +202,7 @@ def deal_num(num_str):
     return num_str.lower().strip()
 
 
-def clear_author_1st(author_str:str):
+def clear_author_1st(author_str: str):
     # 清理括号 防止前面流程没有清理干净
     author_str = re.sub("\\[.*?]", "", author_str)
     author_str = re.sub("\\(.*?\\)", "", author_str)
@@ -209,6 +212,7 @@ def clear_author_1st(author_str:str):
 
     return author_str
 
+
 def is_same_author(a1, a2):
     if get_alphabetic_ratio(a1.strip()) > 0.7 and get_alphabetic_ratio(a2.strip()) > 0.7:
         author_similar_ = AuthorRatio(a1.strip(), a2.strip())
@@ -217,4 +221,15 @@ def is_same_author(a1, a2):
     else:
         if rel_clear(a1.strip()) == rel_clear(a2.strip()):
             return True
-    return False
+    return False
+
+
+def abs_smi(abs_l1, abs_l2):
+    abs_l1 = [cleared for cleared in map(rel_clear, abs_l1) if cleared]
+    abs_l2 = [cleared for cleared in map(rel_clear, abs_l2) if cleared]
+    lists_max = []
+    for abs1, abs2 in list(itertools.product(abs_l1, abs_l2)):
+        max_smi = partial_token_set_ratio(abs1, abs2, processor=rel_clear)
+        lists_max.append(max_smi)
+
+    return max(lists_max)

re_common-10.0.42/re_common/v2/baselibrary/s3object/baseaioboto3.py

@@ -0,0 +1,48 @@
+import aioboto3
+import aiofiles
+from aiobotocore.config import AioConfig
+
+
+# config = AioConfig(connect_timeout=600000, read_timeout=600000, retries={'max_attempts': 3},
+#                    max_pool_connections=10)
+
+class BaseAioBoto3(object):
+
+    def __init__(self, aws_access_key_id, aws_secret_access_key, endpoint_url,
+                 config=AioConfig(max_pool_connections=10)):
+        self.aws_access_key_id = aws_access_key_id
+        self.aws_secret_access_key = aws_secret_access_key
+        self.endpoint_url = endpoint_url
+        self.config = config
+        self.boto_session = None
+
+    async def initialize_class_variable(self):
+        if self.boto_session is None:
+            self.boto_session = aioboto3.Session(
+                aws_access_key_id=self.aws_access_key_id,
+                aws_secret_access_key=self.aws_secret_access_key,
+            )
+
+    async def read_minio_data(self, bucket, key):
+        await self.initialize_class_variable()
+        async with self.boto_session.client("s3", endpoint_url=self.endpoint_url, config=self.config) as s3:
+            s3_ob = await s3.get_object(Bucket=bucket, Key=key)
+            result = await s3_ob["Body"].read()
+            return result
+
+    # 异步下载大文件
+    async def download_file(self, bucket: str, key: str, local_path: str):
+        await self.initialize_class_variable()
+        async with self.boto_session.client("s3", endpoint_url=self.endpoint_url, config=self.config) as s3:
+            response = await s3.get_object(Bucket=bucket, Key=key)
+            body = response["Body"]
+
+            # 用异步方式写入本地
+            async with aiofiles.open(local_path, "wb") as f:
+                while True:
+                    chunk = await body.read(10 * 1024 * 1024)  # 每次读 10MB
+                    if not chunk:
+                        break
+                    await f.write(chunk)
+
+        return local_path

{re_common-10.0.40 → re_common-10.0.42}/re_common/v2/baselibrary/tools/data_processer/base.py

@@ -4,9 +4,9 @@ from typing import List, Generator
 
 class BaseFileReader(ABC):
 
-    def __init__(self, batch_size: int = 10000):
+    def __init__(self, batch_size: int = 10000, read_model: int = 1):
         self.batch_size = batch_size
-        self.read_model = 1
+        self.read_model = read_model
 
     @abstractmethod
     def list_files(self, path: str) -> List[str]:

{re_common-10.0.40 → re_common-10.0.42}/re_common/v2/baselibrary/tools/data_processer/data_processer.py

@@ -43,6 +43,15 @@ class DatabaseHandler:
                 )
                 conn.commit()
 
+    def get_processed_files_count(self):
+        """查看db3存储了多少成功的记录"""
+        with FileLock(self.lock_file):
+            with sqlite3.connect(self.db_file) as conn:
+                cursor = conn.cursor()
+                cursor.execute("SELECT COUNT(*) FROM processed_files")
+                count = cursor.fetchone()[0]
+            return count
+
     def save_processed_files_many(self, file_paths):
         """批量保存处理过的文件路径"""
         if not file_paths:
@@ -110,6 +119,21 @@ class DatabaseHandler:
             print(f"伪造处理记录时出错: {str(e)}")
 
 
+def on_retry(retry_state):
+    # 每次抛错进入该函数打印消息
+    exc = retry_state.outcome.exception()
+    tb = ''.join(traceback.format_exception(type(exc), exc, exc.__traceback__))
+    print(tb)
+    print(
+        f"处理文件 {retry_state.args[0]} 时发生错误: {exc}，正在重试 {retry_state.attempt_number}")
+
+
+def on_retry_error(retry_state):
+    # 最后抛错后调用
+    print(f"处理文件 {retry_state.args[0]} 失败，达到重试上限")
+    return False
+
+
 class DataProcessor:
     def __init__(
             self,
@@ -249,38 +273,6 @@ class DataProcessor:
         for file_path in all_files:
             yield file_path
 
-    @retry(stop=stop_after_attempt(3),
-           wait=wait_random(min=10, max=30),
-           retry=retry_if_result(lambda result: not result),  # 如果返回值是 False（失败），则重试 最后会抛出一个默认错误tenacity.RetryError:
-           reraise=True)
-    async def _batch_process_file(self, hdfs_file_path: str, process_func: Callable[[str], Any],
-                                  write_dir: str = None):
-        """批量更新所有 gz 文件"""
-        # all_succeed = True
-        # for hdfs_file_path in self.get_file_list(hdfs_dir):
-        #     if self.db_handler.is_file_processed(hdfs_file_path):
-        #         print(f"跳过已处理文件: {hdfs_file_path}")
-        #         continue  # 如果文件已处理，跳过
-        #     succeed = await self.retry_process_file(hdfs_file_path, process_func, write_dir)  # 处理文件
-        #     if succeed is False:
-        #         all_succeed = False
-        #
-        # if all_succeed:
-        #     # 处理完成后删除数据库文件
-        #     try:
-        #         if os.path.exists(self.db_file):
-        #             os.remove(self.db_file)
-        #             print(f"已删除断点重试文件: {self.db_file}")
-        #             return True
-        #     except Exception as e:
-        #         print(f"删除断点重试文件失败: {e}")
-        # return False
-        if self.db_handler.is_file_processed(hdfs_file_path):
-            print(f"跳过已处理文件: {hdfs_file_path}")
-            return True  # 如果文件已处理，跳过
-        succeed = await self.retry_process_file(hdfs_file_path, process_func, write_dir)  # 处理文件
-        return succeed
-
     async def process_file_bulk(self, hdfs_file_path, process_func, write_dir):
         """按批次处理单个文件，批量数据传递给处理函数"""
         # 获取文件的数据总量
@@ -391,36 +383,6 @@ class DataProcessor:
                 succeed = await self._batch_process_file(hdfs_file_path, process_func, write_dir)
             if succeed is False:
                 all_succeed = False
-        if all_succeed:
-            # 处理完成后删除数据库文件
-            try:
-                if os.path.exists(self.db_file):
-                    os.remove(self.db_file)
-                    print(f"已删除断点重试文件: {self.db_file}")
-                    return True
-            except Exception as e:
-                print(f"删除断点重试文件失败: {e}")
-        return False
-
-    @retry(stop=stop_after_attempt(3),
-           wait=wait_random(min=10, max=30),
-           retry=retry_if_result(lambda result: not result),  # 如果返回值是 False（失败），则重试 最后会抛出一个默认错误tenacity.RetryError:
-           reraise=True)
-    async def _batch_process_file_bulk(self, hdfs_file_path: str, process_func: Callable[[List[str]], Any],
-                                       write_dir: str = None):
-        """批量处理 gz 文件中的数据"""
-        # 获取所有文件
-        # all_succeed = True
-        # for hdfs_file_path in self.get_file_list(hdfs_dir):
-        #     # 查看是否跳过文件
-        #     if self.db_handler.is_file_processed(hdfs_file_path):
-        #         print(f"跳过已处理文件: {hdfs_file_path}")
-        #         continue  # 跳过已处理文件
-        #     # 开始批量处理文件
-        #     succeed = await self.retry_process_file_bulk(hdfs_file_path, process_func, write_dir)
-        #     if succeed is False:
-        #         all_succeed = False
-        #
         # if all_succeed:
         #     # 处理完成后删除数据库文件
         #     try:
@@ -430,7 +392,17 @@ class DataProcessor:
         #             return True
         #     except Exception as e:
         #         print(f"删除断点重试文件失败: {e}")
-        # return False
+        return all_succeed
+
+    @retry(stop=stop_after_attempt(3),
+           wait=wait_random(min=10, max=30),
+           # retry=retry_if_result(lambda result: not result),  # 如果返回值是 False（失败），则重试 最后会抛出一个默认错误tenacity.RetryError:
+           before_sleep=on_retry,  # 每次抛错后使用
+           retry_error_callback=on_retry_error,  # 如果最后没成功 返回 False
+           reraise=True)  # 如果函数一直失败，重试结束时会 重新抛出最后一次调用时的原始异常。
+    async def _batch_process_file_bulk(self, hdfs_file_path: str, process_func: Callable[[List[str]], Any],
+                                       write_dir: str = None):
+        """批量处理 gz 文件中的数据"""
         # 查看是否跳过文件
         if self.db_handler.is_file_processed(hdfs_file_path):
             print(f"跳过已处理文件: {hdfs_file_path}")
@@ -439,6 +411,21 @@ class DataProcessor:
         succeed = await self.retry_process_file_bulk(hdfs_file_path, process_func, write_dir)
         return succeed
 
+    @retry(stop=stop_after_attempt(3),
+           wait=wait_random(min=10, max=30),
+           # retry=retry_if_result(lambda result: not result),  # 如果返回值是 False（失败），则重试 最后会抛出一个默认错误tenacity.RetryError:
+           before_sleep=on_retry,  # 每次抛错后使用
+           retry_error_callback=on_retry_error,  # 如果最后没成功 返回 False
+           reraise=True)
+    async def _batch_process_file(self, hdfs_file_path: str, process_func: Callable[[str], Any],
+                                  write_dir: str = None):
+        """批量更新所有 gz 文件"""
+        if self.db_handler.is_file_processed(hdfs_file_path):
+            print(f"跳过已处理文件: {hdfs_file_path}")
+            return True  # 如果文件已处理，跳过
+        succeed = await self.retry_process_file(hdfs_file_path, process_func, write_dir)  # 处理文件
+        return succeed
+
 
 # 全局变量，每个进程独立持有
 _processor: DataProcessor | None = None
@@ -506,3 +493,5 @@ def run_worker_many(hdfs_dir: str, process_func: Callable[[List[str]], Any] | Ca
     for result in results:
         if result:
             print(result)
+    db3_count = processor.db_handler.get_processed_files_count()
+    print(f"db3文件数据量{db3_count}，文件实际数据量{len(all_file)}，是否完成全部转移: {db3_count == len(all_file)}")

{re_common-10.0.40 → re_common-10.0.42}/re_common/v2/baselibrary/tools/data_processer/data_reader.py

@@ -12,8 +12,9 @@ from re_common.v2.baselibrary.tools.data_processer.base import BaseFileReader
 
 
 class HDFSFileReader(BaseFileReader):
-    def __init__(self, batch_size: int = 1000, hdfs_url: str = "http://VIP-DC-MASTER-2:9870", hdfs_user: str = "root"):
-        super().__init__(batch_size)
+    def __init__(self, batch_size: int = 1000, read_model: int = 1, hdfs_url: str = "http://VIP-DC-MASTER-2:9870",
+                 hdfs_user: str = "root"):
+        super().__init__(batch_size, read_model)
         self.client = InsecureClient(hdfs_url, user=hdfs_user)
 
     def list_files(self, path: str) -> List[str]:
@@ -48,8 +49,9 @@ class HDFSFileReader(BaseFileReader):
 
 
 class HDFSGZFileReader(BaseFileReader):
-    def __init__(self, batch_size: int = 1000, hdfs_url: str = "http://VIP-DC-MASTER-2:9870", hdfs_user: str = "root"):
-        super().__init__(batch_size)
+    def __init__(self, batch_size: int = 1000, read_model: int = 1, hdfs_url: str = "http://VIP-DC-MASTER-2:9870",
+                 hdfs_user: str = "root"):
+        super().__init__(batch_size, read_model)
         self.hdfs_url = hdfs_url
         self.hdfs_user = hdfs_user
         self.client = None
@@ -99,8 +101,9 @@ class HDFSGZFileReader(BaseFileReader):
 
 
 class HDFSParquetFileReader(BaseFileReader):
-    def __init__(self, batch_size: int = 1000, hdfs_url: str = "http://VIP-DC-MASTER-2:9870", hdfs_user: str = "root"):
-        super().__init__(batch_size)
+    def __init__(self, batch_size: int = 1000, read_model: int = 1, hdfs_url: str = "http://VIP-DC-MASTER-2:9870",
+                 hdfs_user: str = "root"):
+        super().__init__(batch_size, read_model)
         self.client = InsecureClient(hdfs_url, user=hdfs_user)
 
     def list_files(self, path: str) -> List[str]:

re_common-10.0.42/re_common/v2/baselibrary/tools/dir_file_tools.py

@@ -0,0 +1,27 @@
+import json
+import os
+
+
+def scan_dir_fast(path):
+    file_infos = []
+    with os.scandir(path) as entries:
+        for entry in entries:
+            if entry.is_file():
+                info = entry.stat()
+                file_infos.append({
+                    "path": entry.path,
+                    "size": info.st_size
+                })
+    return file_infos
+
+
+def scan_dir(dir_name, result_file):
+    # dir_name r"/share/fulltext/errors"
+    # result_file "file_info_errors.txt"
+    for root, dirs, files in os.walk(dir_name):
+        print(root)
+        lists = scan_dir_fast(root)
+        with open(result_file, "a", encoding="utf-8") as file:
+            for i in lists:
+                if i:
+                    file.write(json.dumps(i, ensure_ascii=False) + "\n")

{re_common-10.0.40 → re_common-10.0.42}/re_common/v2/baselibrary/tools/list_tools.py

@@ -1,4 +1,5 @@
 import itertools
+from collections import Counter
 from typing import List, Any, Tuple
 
 
@@ -67,4 +68,20 @@ def list_to_dict(list_data,key_name):
 
 def split_list_by_step(lst, step=100):
     # 一维列表按照步长转换成二维列表
-    return [lst[i:i + step] for i in range(0, len(lst), step)]
+    return [lst[i:i + step] for i in range(0, len(lst), step)]
+
+
+def list_diff(l1, l2):
+    """
+    非去重差异比较
+    Counter 虽然长得像字典，但它在运算符 & 和 - 上有特殊的定义。
+    这样 能获取重复差集
+    """
+    c1, c2 = Counter(l1), Counter(l2)
+    # 共同部分
+    common = list((c1 & c2).elements())
+    # l1 多余的部分
+    extra1 = list((c1 - c2).elements())
+    # l2 多余的部分
+    extra2 = list((c2 - c1).elements())
+    return common, extra1, extra2

re_common-10.0.42/re_common/v2/baselibrary/tools/tree_processor/builder.py

@@ -0,0 +1,25 @@
+from re_common.v2.baselibrary.tools.tree_processor.node import TreeNode
+
+
+def build_forest(node_list):
+    nodes = {}  # cid -> TreeNode
+    has_parent = set()
+
+    # 第一步：创建所有节点
+    for cid, pid, count in node_list:
+        node = TreeNode(cid, count)
+        nodes[cid] = node
+        if pid is not None:
+            has_parent.add(cid)
+
+    # 第二步：连接 parent-child
+    for cid, pid, _ in node_list:
+        if pid is not None and pid in nodes:
+            parent = nodes[pid]
+            child = nodes[cid]
+            parent.children.append(child)
+            child.parent = parent
+
+    # 第三步：找所有根节点（即没有 parent 的）
+    roots = [node for cid, node in nodes.items() if node.parent is None]
+    return roots  # 返回多棵树的根节点列表

re_common-10.0.42/re_common/v2/baselibrary/tools/tree_processor/node.py

@@ -0,0 +1,13 @@
+class TreeNode:
+    def __init__(self, cid, count):
+        self.id = cid
+        self.count = count
+        self.children = []
+        self.parent = None
+
+    def add_child(self, child):
+        self.children.append(child)
+        child.parent = self
+
+    def is_leaf(self):
+        return len(self.children) == 0

{re_common-10.0.40 → re_common-10.0.42}/re_common/v2/baselibrary/utils/api_net_utils.py

@@ -1,8 +1,11 @@
 import atexit
+import os
 import sys
 import asyncio
+import traceback
+
 import aiohttp
-from typing import Optional
+from typing import Optional, Union
 
 from tenacity import retry, stop_after_attempt, wait_random
 
@@ -62,6 +65,13 @@ def on_retry_error(retry_state):
 
 def on_retry(retry_state):
     # 每次抛错进入该函数打印消息
+
+    # # 获取函数调用参数
+    # args = retry_state.args
+    # kwargs = retry_state.kwargs
+    #
+    # print(id(args[0]._get_session()))
+
     print(
         f"[HTTP 请求重试]"
         f"当前重试 : 第 {retry_state.attempt_number} 次"
@@ -84,6 +94,8 @@ class ApiNetUtils:
     _conn: Optional[aiohttp.TCPConnector] = None
     _session: Optional[aiohttp.ClientSession] = None
     _close_registered: bool = False  # 确保清理函数只注册一次
+    _pid: Optional[int] = None  # 当前进程的 PID
+    lock = asyncio.Lock()
 
     @classmethod
     async def _get_connector(cls) -> aiohttp.TCPConnector:
@@ -96,9 +108,9 @@ class ApiNetUtils:
             cls._conn = aiohttp.TCPConnector(
                 limit=50,  # 最大连接数
                 ssl=False,  # 禁用SSL验证（按需开启）
-                force_close=True,  # 保持连接活跃
-                # enable_cleanup_closed=True,  # 自动清理关闭的连接 #
-                # keepalive_timeout=4.99  # 比服务器的5s 小一点
+                force_close=False,  # 保持连接活跃
+                enable_cleanup_closed=True,  # 自动清理关闭的连接 #
+                keepalive_timeout=4.99  # 比服务器的5s 小一点
             )
         return cls._conn
 
@@ -108,25 +120,41 @@ class ApiNetUtils:
         获取共享会话（线程安全的延迟初始化）
         包含自动注册清理机制
         """
-        if cls._session is None or cls._session.closed or cls.is_loop_closed(cls._session):
-            if cls._session:
-                await cls.close()
-            # 获取连接器（会自动初始化）
-            connector = await cls._get_connector()
-
-            # 强制获取新的事件循环
-            loop = asyncio.get_event_loop()
+        async with cls.lock:
+            current_pid = os.getpid()
+            if cls._pid != current_pid:
+                # 新进程，重新初始化
+                if cls._session:
+                    await cls.close()
+                cls._pid = current_pid
+
+            if cls._session is None or cls._session.closed or cls.is_loop_closed(cls._session):
+                if cls._session:
+                    await cls.close()
+                # 获取连接器（会自动初始化）
+                connector = await cls._get_connector()
+
+                # 强制获取新的事件循环
+                loop = asyncio.get_event_loop()
+
+                timeout = aiohttp.ClientTimeout(
+                    total=120,  # 整个请求最多 30 秒
+                    connect=10,  # 最多 5 秒连接
+                    sock_connect=10,
+                    sock_read=110,  # 最多 20 秒读取响应数据
+                )
 
-            # 创建新会话
-            cls._session = aiohttp.ClientSession(
-                connector=connector,
-                timeout=aiohttp.ClientTimeout(total=30),  # 默认30秒超时
-                loop=loop)  # 显式指定事件循环
+                # 创建新会话
+                cls._session = aiohttp.ClientSession(
+                    connector=connector,
+                    timeout=timeout,  # 默认30秒超时
+                    loop=loop,
+                )  # 显式指定事件循环
 
-            # # 注册退出时的清理钩子
-            cls._register_cleanup()
+                # # 注册退出时的清理钩子
+                cls._register_cleanup()
 
-        return cls._session
+            return cls._session
 
     @staticmethod
     def is_loop_closed(session: aiohttp.ClientSession) -> bool:
@@ -135,7 +163,7 @@ class ApiNetUtils:
         """
         loop = session._loop  # 获取会话绑定的事件循环
         if loop.is_closed():
-            # print("Event loop is closed")
+            print("Event loop is closed")
             return True
         # print("Event loop not is closed")
         return False

{re_common-10.0.40 → re_common-10.0.42}/re_common/v2/baselibrary/utils/basetime.py

@@ -75,3 +75,20 @@ class BaseTime(object):
         current_time = BaseTime.get_current_beijing_time()
         last_time = BaseTime.parse_beijing_time(last_time_str)
         return current_time.hour != last_time.hour
+
+    @staticmethod
+    def is_weekday(num_weekday: int) -> bool:
+        """
+        判断当前日期是否为指定星期。
+
+        参数:
+            num_weekday (int): 表示星期的数字（1=星期一, 2=星期二, ..., 7=星期日）。
+
+        返回:
+            bool: 如果当前日期不是指定的星期，则返回 True；否则返回 False。
+
+        示例:
+            如果 num_weekday=6（星期六），而今天是星期五（weekday()=4），则返回 True。
+        """
+        current_weekday = datetime.now().weekday()  # 获取当前星期（0=星期一, 1=星期二, ..., 6=星期日）
+        return current_weekday != num_weekday - 1

{re_common-10.0.40 → re_common-10.0.42}/re_common/v2/baselibrary/utils/db.py

@@ -94,7 +94,6 @@ aiomysql_pool = None
 pool_lock = asyncio.Lock()  # 全局异步锁
 
 
-
 async def init_aiomysql_pool_async():
     global aiomysql_pool
     if aiomysql_pool is None:
@@ -110,6 +109,7 @@ client = None
 motor_fs_lock = asyncio.Lock()  # 全局异步锁
 _loop_id_mongo = None
 
+
 async def check_connection(client):
     try:
         print("check mongodb client ping")
@@ -142,6 +142,7 @@ async def init_motor_async(uri, db_name, bucket_name, is_reload=False):
                 _loop_id_mongo = id(asyncio.get_running_loop())
     return motor_fs, client
 
+
 # async def run_main():
 #     while True:
 #         uri = "mongodb://192.168.98.80:27001/wpdc"
@@ -154,3 +155,20 @@ async def init_motor_async(uri, db_name, bucket_name, is_reload=False):
 #
 # if __name__ == "__main__":
 #     asyncio.run(run_main())
+
+
+def get_connection(autocommit: bool = True) -> Connection:
+    from pymysql import Connection
+    from pymysql.cursors import DictCursor
+    import pymysql
+    db_conf = {
+        "host": "192.168.98.55",
+        "port": 4000,
+        "user": "dataware_house_baseUser",
+        "password": "FF19AF831AEBD580B450B16BF9264200",
+        "database": "dataware_house_base",
+        "autocommit": autocommit,
+        "cursorclass": DictCursor,
+    }
+    conn: Connection = pymysql.connect(**db_conf)
+    return conn