mdbq 0.4.5__py3-none-any.whl → 1.0.0__py3-none-any.whl

mdbq/aggregation/aggregation.py

@@ -11,6 +11,7 @@ import platform
 import json
 from mdbq.mongo import mongo
 from mdbq.mysql import mysql
+from mdbq.aggregation import df_types
 from mdbq.config import get_myconf
 from mdbq.config import set_support
 from mdbq.dataframe import converter
@@ -25,109 +26,15 @@ warnings.filterwarnings('ignore')
 1. DatabaseUpdate: 程序用于对爬虫下载的原始数据进行清洗并入库;
     数据清洗主要包括对字段名的非法字符处理，对 df 中的非法值进行预处理;
     数据入库时会较检并更新本地 json 文件的 dtypes 信息;
-    若 json 缺失 dtypes 信息, 可用 update_dtypte 先更新, 或者手动修改添加本地 json 信息; 
+    若 json 缺失 dtypes 信息, 可用 update_df_types_to_json 先更新, 或者手动修改添加本地 json 信息; 
 2. DataTypes: 类用于将某个csv文件的 dtypes 信息存入本地 json 文件, 会调用 converter 对 df 预处理;
     作用于完善某个数据库 dtypes 信息，可以使用本函数更新;
-3. update_dtypte: 函数将一个 csv 文件的 dtypes 信息更新至本地 json 文件;
+3. update_df_types_to_json: 函数将一个 csv 文件的 dtypes 信息更新至本地 json 文件;
 4. upload: 函数将一个文件夹上传至数据库;
-    如果本地 json 中确实这个数据库的 dtypes 信息, 请用 update_dtypte 更新 json 文件再执行数据上传;
+    如果本地 json 中确实这个数据库的 dtypes 信息, 请用 update_df_types_to_json 更新 json 文件再执行数据上传;
 """
 
 
-class DataTypes:
-    """
-    将某表的列信息添加到 json 示例:
-    file = '/Users/xigua/Downloads/天猫直通车旧报表(未排重版本).csv'
-    df = pd.read_csv(file, encoding='utf-8_sig', header=0, na_filter=False)
-    d = DataTypes()
-    d.read_dtypes(
-        df=df,
-        db_name='天猫数据2',
-        collection_name='旧版报表',
-        is_file_dtype=False,  # 关闭文件优先
-    )
-    d.dtypes_to_file()
-    """
-    def __init__(self):
-        self.path = set_support.SetSupport(dirname='support').dirname
-        if not os.path.exists(self.path):
-            os.mkdir(self.path)
-        self.json_file = os.path.join(self.path, 'data_types.json')
-        # self.datas = json.loads('{}')  # 等待写入 json 文件的 dtypes 数据
-        self.datas = {'json统计': {'数据库量': 0, '集合数量': 0, '字段量': 0}}
-        self.json_before()
-
-    def json_before(self):
-        """ 本地 json 文件的 dtypes 信息, 初始化更新给 self.datas """
-        if os.path.isfile(self.json_file):
-            with open(self.json_file, 'r', encoding='utf-8_sig') as json_file:
-                json_ = json.load(json_file)
-                self.datas.update(json_)
-
-    def load_dtypes(self, db_name, collection_name, ):
-        return self.datas[db_name][collection_name]
-
-
-    def read_dtypes(self, db_name, collection_name, df=pd.DataFrame(), is_file_dtype=True):
-        """
-        读取 df 的 dtypes, 并更新本地 json 文件
-        期间会 清理不合规的列名, 并对数据类型进行转换(尝试将 object 类型转为 int 或 float)
-        返回: df 的 dtypes, 后续使用示例: df = df.astype(dtypes, errors='ignore')
-        is_file_dtype=True: 默认情况下以旧 json 优先, 即允许手动指定 json 文件里面的数据类型
-        """
-        if len(df) == 0:
-            return
-        cv = converter.DataFrameConverter()
-        df = cv.convert_df_cols(df=df)  # 清理 dataframe 列名的不合规字符
-        dtypes = df.dtypes.apply(str).to_dict()
-        dtypes = {db_name: {collection_name: dtypes}}
-
-        if not self.datas:  # 如果不存在本地 json 文件, 直接返回即可
-            self.datas.update(dtypes)
-            return self.datas[db_name][collection_name]
-        else:  # 存在则读取，并更新 df 的 dtypes
-            if db_name in list(self.datas.keys()):  # ['京东数据2', '天猫数据2', '生意参谋数据2', '生意经2']
-                if collection_name in list(self.datas[db_name].keys()):
-                    if is_file_dtype:  # 旧数据优先
-                        # # 用 dtypes 更新, 允许手动指定 json 文件里面的数据类型
-                        dtypes[db_name][collection_name].update(self.datas[db_name][collection_name])
-                        # 将 dtypes 更新进去，使 self.datas 包含新旧信息
-                        self.datas[db_name][collection_name].update(dtypes[db_name][collection_name])
-                    else:  # 新数据优先
-                        self.datas[db_name][collection_name].update(dtypes[db_name][collection_name])
-                else:
-                    if is_file_dtype:  # 旧数据优先
-                        dtypes[db_name].update(self.datas[db_name])
-                        self.datas[db_name].update(dtypes[db_name])
-                    else:
-                        self.datas[db_name].update(dtypes[db_name])
-            else:
-                # dtypes.update(self.datas)  # 可以注释掉, 因为旧数据 self.datas 是空的
-                self.datas.update(dtypes)
-            dbs = 0
-            collections = 0
-            cols = 0
-            # self.datas.pop('json统计')
-            for k, v in self.datas.items():
-                if k == 'json统计':
-                    continue
-                dbs += 1
-                for d, j in v.items():
-                    collections += 1
-                    for t, p in j.items():
-                        cols += 1
-            tips = {'json统计': {'数据库量': dbs, '集合数量': collections, '字段量': cols}}
-            self.datas.update(tips)
-            return self.datas[db_name][collection_name]  # 返回 df 的 dtypes
-
-    def dtypes_to_file(self):
-        """ 保存为本地 json 文件 """
-        # print(self.datas)
-        with open(self.json_file, 'w', encoding='utf-8_sig') as f:
-            json.dump(self.datas, f, ensure_ascii=False, sort_keys=True, indent=4)
-        time.sleep(1)
-
-
 class DatabaseUpdate:
     def __init__(self, path):
         self.path = path  # 数据所在目录, 即: 下载文件夹
@@ -142,7 +49,6 @@ class DatabaseUpdate:
             print(f'1.1.0 初始化时传入了不存在的目录: {self.path}')
             return
 
-        json_data = DataTypes()  # json 文件, 包含数据的 dtypes 信息
         for root, dirs, files in os.walk(self.path, topdown=False):
             for name in files:
                 if '~$' in name or '.DS' in name or '.localized' in name or '.ini' in name or '$RECYCLE.BIN' in name or 'Icon' in name:
@@ -680,13 +586,6 @@ class DatabaseUpdate:
                     except Exception as e:
                         print(f'{name},  {e}')
                 if len(df) > 0:
-                    # 创建包含 dtypes 信息的 json 文件
-                    json_data.read_dtypes(
-                        df=df,
-                        db_name=db_name,
-                        collection_name=collection_name,
-                        is_file_dtype=True,  # 默认本地文件优先: True
-                    )
                     # 将数据传入 self.datas 等待更新进数据库
                     self.datas.append(
                         {
@@ -695,10 +594,8 @@ class DatabaseUpdate:
                             '数据主体': df,
                         }
                     )
-        json_data.dtypes_to_file()  # 写入 json 文件, 包含数据的 dtypes 信息
 
         # 品销宝一个表格里面包含多个 sheet, 最好是单独处理
-        json_data = DataTypes()  # json 文件, 包含数据的 dtypes 信息
         for root, dirs, files in os.walk(self.path, topdown=False):
             for name in files:
                 if '~$' in name or '.DS' in name or '.localized' in name or '.jpg' in name or '.png' in name:
@@ -720,12 +617,6 @@ class DatabaseUpdate:
                         df.insert(loc=1, column='报表类型', value=sheet4)
                         db_name = '天猫数据2'
                         collection_name = f'推广数据_品销宝_{sheet4}'
-                        json_data.read_dtypes(
-                            df=df,
-                            db_name=db_name,
-                            collection_name=collection_name,
-                            is_file_dtype=False,
-                        )
                         self.datas.append(
                             {
                                 '数据库名': db_name,
@@ -735,7 +626,6 @@ class DatabaseUpdate:
                         )
                     if is_move:
                         os.remove(os.path.join(root, name))
-        json_data.dtypes_to_file()  # 写入 json 文件, 包含数据的 dtypes 信息
 
         df = self.date_table()  # 创建一个日期表
         self.datas.append(
@@ -750,6 +640,7 @@ class DatabaseUpdate:
         """
         将清洗后的 df 上传数据库
         """
+        df_to_json = dtypes.DataTypes()  # json 文件, 包含数据的 dtypes 信息
         for service_database in service_databases:
             for service_name, database in service_database.items():
                 # print(service_name, database)
@@ -766,7 +657,13 @@ class DatabaseUpdate:
                         drop_duplicates=False,
                     )
                     for data in self.datas:
-                        df, db_name, collection_name = data['数据主体'], data['数据库名'], data['集合名称']
+                        db_name, collection_name, df = data['数据库名'], data['集合名称'], data['数据主体']
+                        df_to_json.get_df_types(
+                            df=df,
+                            db_name=db_name,
+                            collection_name=collection_name,
+                            is_file_dtype=True,  # 默认本地文件优先: True
+                        )
                         d.df_to_mongo(df=df, db_name=db_name, collection_name=collection_name)
 
                 elif database == 'mysql':
@@ -782,7 +679,14 @@ class DatabaseUpdate:
                     )
                     for data in self.datas:
                         df, db_name, collection_name = data['数据主体'], data['数据库名'], data['集合名称']
+                        df_to_json.get_df_types(
+                            df=df,
+                            db_name=db_name,
+                            collection_name=collection_name,
+                            is_file_dtype=True,  # 默认本地文件优先: True
+                        )
                         m.df_to_mysql(df=df, db_name=db_name, tabel_name=collection_name)
+                df_to_json.as_json_file()  # 写入 json 文件, 包含数据的 dtypes 信息
 
     def new_unzip(self, path=None, is_move=None):
         """
@@ -929,26 +833,9 @@ class DatabaseUpdate:
         df.sort_values('日期', ascending=False, ignore_index=True, inplace=True)
         return df
 
-def update_dtypte():
-    """ 更新一个文件的 dtype 信息到 json 文件 """
-    file = '/Users/xigua/数据中心/原始文件2/月数据/流量来源/【生意参谋平台】无线店铺流量来源-2023-04-01_2023-04-30.csv'
-    df = pd.read_csv(file, encoding='utf-8_sig', header=0, na_filter=False)
-    d = DataTypes()
-    d.read_dtypes(
-        df=df,
-        db_name='生意参谋数据2',
-        collection_name='店铺来源_月数据',
-        is_file_dtype=True,  # 日常需开启文件优先, 正常不要让新文件修改 json 已有的类型
-    )
-    d.dtypes_to_file()
-
 
-def upload():
+def upload(path, db_name, collection_name):
     """ 上传一个文件夹到数据库 """
-    path = '/Users/xigua/数据中心/原始文件2/生意经/店铺指标'
-    db_name = '生意经2'
-    collection_name = '店铺指标'
-
     username, password, host, port = get_myconf.select_config_values(
         target_service='home_lx',
         database='mongodb',
@@ -981,8 +868,8 @@ def upload():
         port=port,
     )
 
-    dt = DataTypes()
-    dtypes = dt.load_dtypes(
+    df_to_json = df_types.DataTypes()
+    dtypes = df_to_json.load_dtypes(
         db_name=db_name,
         collection_name=collection_name,
     )
@@ -1007,8 +894,6 @@ def upload():
                         intersection_keys = dtypes.keys() & old_dt.keys()  # 获取两个字典键的交集
                         dtypes = {k: dtypes[k] for k in intersection_keys}  # 使用交集的键创建新字典
                         df = df.astype(dtypes)
-                        # print(intersection_dict)
-                    # print(df)
 
                     d.df_to_mongo(df=df, db_name=db_name, collection_name=collection_name)
                     m.df_to_mysql(df=df, db_name=db_name, tabel_name=collection_name)
@@ -1034,6 +919,8 @@ def main():
 if __name__ == '__main__':
     # username, password, host, port = get_myconf.select_config_values(target_service='nas', database='mysql')
     # print(username, password, host, port)
-
-    main()
-    # upload()
+    upload(
+        path='/Users/xigua/数据中心/原始文件2/生意经/地域分布',
+        db_name = '生意经2',
+        collection_name = '省份城市分析',
+    )

mdbq/aggregation/df_types.py

@@ -0,0 +1,180 @@
+# -*- coding:utf-8 -*-
+import warnings
+import pandas as pd
+import numpy as np
+import chardet
+import zipfile
+
+from numpy import dtype
+from pandas.tseries.holiday import next_monday
+from pyzipper import PyZipFile
+import os
+import platform
+import json
+import pymysql
+from mdbq.mongo import mongo
+from mdbq.mysql import mysql
+from mdbq.mysql import s_query
+from mdbq.config import get_myconf
+from mdbq.config import set_support
+from mdbq.dataframe import converter
+import datetime
+import time
+import re
+import shutil
+import getpass
+
+from sqlalchemy.dialects.postgresql.pg_catalog import pg_get_serial_sequence
+
+warnings.filterwarnings('ignore')
+"""
+1. 记录 dataframe 或者数据库的列信息(dtypes)
+2. 更新 mysql 中所有数据库的 dtypes 信息到本地 json
+"""
+
+
+class DataTypes:
+    """
+     数据简介: 记录 dataframe 或者数据库的列信息(dtypes)，可以记录其信息或者加载相关信息用于入库使用，
+     第一字段为分类(如 dataframe/mysql)，第二字段为数据库名，第三字段为集合名，第四段列名及其数据类型
+    """
+    def __init__(self):
+        self.datas = {
+            "json统计":
+                {
+                    "字段量": 0,
+                    "数据库量": 0,
+                    "集合数量": 0
+                }
+        }
+        self.path = set_support.SetSupport(dirname='support').dirname
+        self.json_file = os.path.join(self.path, 'df_types.json')
+        if not os.path.isdir(self.path):
+            os.makedirs(self.path)
+        if not os.path.isfile(self.json_file):
+            with open(self.json_file, 'w', encoding='utf-8_sig') as f:
+                json.dump(self.datas, f, ensure_ascii=False, sort_keys=True, indent=4)
+        self.json_before()
+
+    def json_before(self):
+        """ 本地 json 文件的 dtypes 信息, 初始化更新给 self.datas """
+        with open(self.json_file, 'r', encoding='utf-8_sig') as f:
+            json_ = json.load(f)
+            self.datas.update(json_)
+
+    def get_df_types(self, db_name, collection_name, df=pd.DataFrame(), is_file_dtype=True):
+        """
+        读取 df 的 dtypes, 并更新本地 json 文件
+        期间会 清理不合规的列名, 并对数据类型进行转换(尝试将 object 类型转为 int 或 float)
+        返回: df 的 dtypes, 后续使用示例: df = df.astype(dtypes, errors='ignore')
+        is_file_dtype=True: 默认情况下以旧 json 优先, 即允许手动指定 json 文件里面的数据类型
+        """
+        if len(df) == 0:
+            return
+        cv = converter.DataFrameConverter()
+        df = cv.convert_df_cols(df=df)  # 清理 dataframe 非法值
+        dtypes = df.dtypes.apply(str).to_dict()
+        dtypes = {db_name: {collection_name: dtypes}}
+
+        if not self.datas:  # 如果不存在本地 json 文件, 直接返回即可
+            self.datas.update(dtypes)
+            return self.datas[db_name][collection_name]
+        else:  # 存在则读取，并更新 df 的 dtypes
+            if db_name in list(self.datas.keys()):  # ['京东数据2', '天猫数据2', '生意参谋数据2', '生意经2']
+                if collection_name in list(self.datas[db_name].keys()):
+                    if is_file_dtype:  # 旧数据优先
+                        # # 用 dtypes 更新, 允许手动指定 json 文件里面的数据类型
+                        dtypes[db_name][collection_name].update(self.datas[db_name][collection_name])
+                        # 将 dtypes 更新进去，使 self.datas 包含新旧信息
+                        self.datas[db_name][collection_name].update(dtypes[db_name][collection_name])
+                    else:  # 新数据优先
+                        self.datas[db_name][collection_name].update(dtypes[db_name][collection_name])
+                else:
+                    if is_file_dtype:  # 旧数据优先
+                        dtypes[db_name].update(self.datas[db_name])
+                        self.datas[db_name].update(dtypes[db_name])
+                    else:
+                        self.datas[db_name].update(dtypes[db_name])
+            else:
+                # dtypes.update(self.datas)  # 可以注释掉, 因为旧数据 self.datas 是空的
+                self.datas.update(dtypes)
+            dbs = 0
+            collections = 0
+            cols = 0
+            # self.datas.pop('json统计')
+            for k, v in self.datas.items():
+                if k == 'json统计':
+                    continue
+                dbs += 1
+                for d, j in v.items():
+                    collections += 1
+                    for t, p in j.items():
+                        cols += 1
+            tips = {'json统计': {'数据库量': dbs, '集合数量': collections, '字段量': cols}}
+            self.datas.update(tips)
+            return self.datas[db_name][collection_name]  # 返回 df 的 dtypes
+
+    def as_json_file(self):
+        """ 保存为本地 json 文件 """
+        with open(self.json_file, 'w', encoding='utf-8_sig') as f:
+            json.dump(
+                self.datas,
+                f,
+                ensure_ascii=False,  # 默认True，非ASCII字符将被转义。如为False，则非ASCII字符会以\uXXXX输出
+                sort_keys=True,  # 默认为False。如果为True，则字典的输出将按键排序。
+                indent=4,
+            )
+        time.sleep(1)
+
+    def df_dtypes_to_json(self, db_name, collection_name, path, df=pd.DataFrame(), is_file_dtype=True):
+        if len(df) == 0:
+            return
+        cv = converter.DataFrameConverter()
+        df = cv.convert_df_cols(df=df)  # 清理 dataframe 列名的不合规字符
+        dtypes = df.dtypes.apply(str).to_dict()
+        dtypes = {'dataframe': {db_name: {collection_name: dtypes}}}
+        self.dtypes_to_json(dtypes=dtypes, cl='dataframe', db_name=db_name, collection_name=collection_name, path=path, is_file_dtype=is_file_dtype)
+
+    def load_dtypes(self, db_name, collection_name):
+        if db_name in list(self.datas.keys()):
+            if collection_name in list(self.datas[db_name].keys()):
+                return self.datas[db_name][collection_name]
+            else:
+                print(f'不存在的集合名信息: {collection_name}, 文件位置: {self.json_file}')
+                return {}
+        else:
+            print(f'不存在的数据库信息: {db_name}, 文件位置: {self.json_file}')
+            return {}
+
+
+def update_df_types_to_json(file, db_name, collection_name, is_file_dtype=True):
+    """ 更新一个文件的 dtype 信息到 json 文件 """
+    df = pd.read_csv(file, encoding='utf-8_sig', header=0, na_filter=False)
+    df_to_json = DataTypes()
+    df_to_json.get_df_types(
+        df=df,
+        db_name=db_name,
+        collection_name=collection_name,
+        is_file_dtype=is_file_dtype,  # 日常需开启文件优先, 正常不要让新文件修改 json 已有的类型
+    )
+    df_to_json.as_json_file()
+    print(f'json文件已存储: {df_to_json.json_file}')
+
+
+def test_load_dtypes(db_name, collection_name):
+    d = DataTypes()
+    res = d.load_dtypes(db_name=db_name, collection_name=collection_name)
+    print(res)
+
+
+if __name__ == '__main__':
+    file = '/Users/xigua/数据中心/pandas数据源/店铺日报.csv'
+    update_df_types_to_json(
+        file=file,
+        db_name='pandas数据源',
+        collection_name='店铺日报',
+        is_file_dtype=True,
+    )
+    # test_load_dtypes(db_name='pandas数据源', collection_name='店铺日报')
+
+

mdbq/aggregation/mysql_types.py

@@ -0,0 +1,231 @@
+# -*- coding:utf-8 -*-
+import warnings
+import pandas as pd
+import numpy as np
+import chardet
+import zipfile
+
+from numpy import dtype
+from pandas.tseries.holiday import next_monday
+from pyzipper import PyZipFile
+import os
+import platform
+import json
+import pymysql
+from mdbq.mongo import mongo
+from mdbq.mysql import mysql
+from mdbq.mysql import s_query
+from mdbq.config import get_myconf
+from mdbq.config import set_support
+from mdbq.dataframe import converter
+import datetime
+import time
+import re
+import shutil
+import getpass
+
+from sqlalchemy.dialects.postgresql.pg_catalog import pg_get_serial_sequence
+
+warnings.filterwarnings('ignore')
+"""
+1. 记录 dataframe 或者数据库的列信息(dtypes)
+2. 更新 mysql 中所有数据库的 dtypes 信息到本地 json
+"""
+
+
+class DataTypes:
+    """
+     数据简介: 记录 dataframe 或者数据库的列信息(dtypes)，可以记录其信息或者加载相关信息用于入库使用，
+     第一字段为分类(如 dataframe/mysql)，第二字段为数据库名，第三字段为集合名，第四段列名及其数据类型
+    """
+    def __init__(self):
+        self.datas = {
+            '_json统计':
+                {
+                    '分类': 0,
+                    '数据库量': 0,
+                    '集合数量': 0,
+                    '字段量': 0,
+                    '数据简介': '记录 dataframe 或者数据库的列信息(dtypes)',
+                }
+        }
+        self.path = set_support.SetSupport(dirname='support').dirname
+        self.json_file = os.path.join(self.path, 'mysql_types.json')
+        if not os.path.isdir(self.path):
+            os.makedirs(self.path)
+        if not os.path.isfile(self.json_file):
+            with open(self.json_file, 'w', encoding='utf-8_sig') as f:
+                json.dump(self.datas, f, ensure_ascii=False, sort_keys=True, indent=4)
+        self.json_before()
+
+    def json_before(self):
+        """ 本地 json 文件的 dtypes 信息, 初始化更新给 self.datas """
+        with open(self.json_file, 'r', encoding='utf-8_sig') as f:
+            json_ = json.load(f)
+            self.datas.update(json_)
+
+    def get_mysql_types(self, cl, dtypes, db_name, tabel_name, is_file_dtype=True):
+        """ 更新 mysql 的 types 信息到 json 文件 """
+        if cl in self.datas.keys():
+            if db_name in list(self.datas[cl].keys()):  # ['京东数据2', '天猫数据2', '生意参谋数据2', '生意经2']
+                if tabel_name in list(self.datas[cl][db_name].keys()):
+                    if is_file_dtype:  # 旧数据优先
+                        # # 用 dtypes 更新, 允许手动指定 json 文件里面的数据类型
+                        dtypes[cl][db_name][tabel_name].update(self.datas[cl][db_name][tabel_name])
+                        # 将 dtypes 更新进去，使 self.datas 包含新旧信息
+                        self.datas[cl][db_name][tabel_name].update(dtypes[cl][db_name][tabel_name])
+                    else:  # 新数据优先
+                        self.datas[cl][db_name][tabel_name].update(dtypes[cl][db_name][tabel_name])
+                else:
+                    if is_file_dtype:  # 旧数据优先
+                        dtypes[cl][db_name].update(self.datas[cl][db_name])
+                        self.datas[cl][db_name].update(dtypes[cl][db_name])
+                    else:
+                        self.datas[cl][db_name].update(dtypes[cl][db_name])
+            else:
+                # dtypes.update(self.datas)  # 可以注释掉, 因为旧数据 self.datas 是空的
+                self.datas[cl].update(dtypes[cl])
+        else:
+            self.datas.update(dtypes)
+
+        cif = 0  # 分类
+        dbs = 0  # 数据库
+        collections = 0  # 集合
+        cols = 0  # 字段
+        for k, v in self.datas.items():
+            if k == '_json统计':
+                continue  # 不统计头信息
+            cif += 1
+            for t, g in v.items():
+                dbs += 1
+                for d, j in g.items():
+                    collections += 1
+                    for t, p in j.items():
+                        cols += 1
+        tips = {'分类': cif, '数据库量': dbs, '集合数量': collections, '字段量': cols}
+        self.datas['_json统计'].update(tips)
+        # with open(json_file, 'w', encoding='utf-8_sig') as f:
+        #     json.dump(
+        #         self.datas,
+        #         f,
+        #         ensure_ascii=False,  # 默认True，非ASCII字符将被转义。如为False，则非ASCII字符会以\uXXXX输出
+        #         sort_keys=True,  # 默认为False。如果为True，则字典的输出将按键排序。
+        #         indent=4,
+        #     )
+
+    def as_json_file(self):
+        """ 保存为本地 json 文件 """
+        with open(self.json_file, 'w', encoding='utf-8_sig') as f:
+            json.dump(
+                self.datas,
+                f,
+                ensure_ascii=False,  # 默认True，非ASCII字符将被转义。如为False，则非ASCII字符会以\uXXXX输出
+                sort_keys=True,  # 默认为False。如果为True，则字典的输出将按键排序。
+                indent=4,
+            )
+        time.sleep(1)
+
+    def load_dtypes(self, db_name, tabel_name, cl='mysql', ):
+        """
+        mysql.py 程序从本地文件中读取 dtype 信息
+        如果缺失 dtypes 信息，则执行 mysql_all_dtypes 以便更新所有数据库 dtypes 信息到 json 文件
+        """
+        if cl in self.datas.keys():
+            if db_name in list(self.datas[cl].keys()):
+                if tabel_name in list(self.datas[cl][db_name].keys()):
+                    return self.datas[cl][db_name][tabel_name]
+                else:
+                    print(f'不存在的集合名信息: {tabel_name}, 文件位置: {self.json_file}')
+                    mysql_all_dtypes()  # 更新 mysql 中所有数据库的 dtypes 信息到本地 json
+                    return {}
+            else:
+                print(f'不存在的数据库信息: {db_name}, 文件位置: {self.json_file}')
+                mysql_all_dtypes()  # 更新 mysql 中所有数据库的 dtypes 信息到本地 json
+                return {}
+        else:
+            print(f'不存在的数据分类: {cl}, 文件位置: {self.json_file}')
+            mysql_all_dtypes()  # 更新 mysql 中所有数据库的 dtypes 信息到本地 json
+            return {}
+
+
+def mysql_all_dtypes(path=None):
+    """
+    更新笔记本 mysql 中所有数据库的 dtypes 信息到本地 json
+    """
+    if not path:
+        path = set_support.SetSupport(dirname='support').dirname
+
+    username, password, host, port = get_myconf.select_config_values(target_service='home_lx', database='mysql')
+    config = {
+        'host': host,
+        'port': port,
+        'user': username,
+        'password': password,
+        'charset': 'utf8mb4',  # utf8mb4 支持存储四字节的UTF-8字符集
+        'cursorclass': pymysql.cursors.DictCursor,
+    }
+
+    connection = pymysql.connect(**config)  # 连接数据库
+    with connection.cursor() as cursor:
+        sql = "SHOW DATABASES;"
+        cursor.execute(sql)
+        db_name_lists = cursor.fetchall()
+        db_name_lists = [item['Database'] for item in db_name_lists]
+        connection.close()
+
+    sys_lists = ['information_schema', 'mysql', 'performance_schema', 'sakila', 'sys']
+    db_name_lists = [item for item in db_name_lists if item not in sys_lists]
+
+    # db_name_lists = [
+    #     '京东数据2',
+    #     '天猫数据2',
+    #     '市场数据2',
+    #     '生意参谋数据2',
+    #     '生意经2',
+    #     '属性设置2',
+    #     '聚合数据',
+    # ]
+    results = []
+    for db_name in db_name_lists:
+        config.update({'database': db_name})  # 添加更新 config 字段
+        connection = pymysql.connect(**config)  # 连接数据库
+        try:
+            with connection.cursor() as cursor:
+                sql = f"SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA = '{db_name}';"
+                sql = "SHOW TABLES;"
+                cursor.execute(sql)
+                table_name = cursor.fetchall()
+                for table in table_name:
+                    for k, v in table.items():
+                        results.append({db_name: v})
+        except:
+            pass
+        finally:
+            connection.close()
+        time.sleep(0.5)
+
+    d = DataTypes()
+    for result in results:
+        for db_name, tabel_name in result.items():
+            print(f'获取列信息 数据库: < {db_name} >, 数据表: < {tabel_name} >')
+            # d.mysql_dtypes_to_json(db_name=db_name, tabel_name=tabel_name, path=path)
+            sq = s_query.QueryDatas(username=username, password=password, host=host, port=port)
+            # 获取数据表的指定列, 返回列表
+            # [{'视频bv号': 'BV1Dm4y1S7BU', '下载进度': 1}, {'视频bv号': 'BV1ov411c7US', '下载进度': 1}]
+            name_type = sq.dtypes_to_list(db_name=db_name, tabel_name=tabel_name)
+            if name_type:
+                dtypes = {item['COLUMN_NAME']: item['COLUMN_TYPE'] for item in name_type}
+                dtypes = {'mysql': {db_name: {tabel_name: dtypes}}}
+                d.get_mysql_types(
+                    dtypes=dtypes, 
+                    cl='mysql', 
+                    db_name=db_name, 
+                    tabel_name=tabel_name,
+                    is_file_dtype=True
+                )
+            else:
+                print(f'数据库回传数据(name_type)为空')
+    d.as_json_file()
+
+if __name__ == '__main__':
+    mysql_all_dtypes()  # 更新 mysql 中所有数据库的 dtypes 信息到本地 json

mdbq/aggregation/query_data.py

@@ -525,5 +525,5 @@ def data_aggregation(service_databases=[{}]):
 
 
 if __name__ == '__main__':
-    data_aggregation(service_databases=[{'home_lx': 'mysql'}])
+    data_aggregation(service_databases=[{'company': 'mysql'}])
     # optimize_data.op_data(service_databases=[{'company': 'mysql'}], days=3650)  # 立即启动对聚合数据的清理工作

mdbq/dataframe/converter.py

@@ -9,6 +9,51 @@ class DataFrameConverter(object):
         self.df = df
 
     def convert_df_cols(self, df=pd.DataFrame({})):
+        """
+        清理 dataframe 非法值
+        对数据类型进行转换(尝试将 object 类型转为 int 或 float)
+        """
+        if len(df) == 0:
+            df = self.df
+            if len(df) == 0:
+                return
+        # dtypes = df.dtypes.apply(str).to_dict()  # 将 dataframe 数据类型转为字典形式
+        df.replace([np.inf, -np.inf], 0, inplace=True)  # 清理一些非法值
+        df.replace(to_replace=['\\N', '-', '--', '', 'nan'], value=0, regex=False, inplace=True)  # 替换掉特殊字符
+        df.replace(to_replace=[','], value='', regex=True, inplace=True)
+        df.replace(to_replace=['="'], value='', regex=True, inplace=True)  # ="和"不可以放在一起清洗, 因为有: id=86785565
+        df.replace(to_replace=['"'], value='', regex=True, inplace=True)
+        cols = df.columns.tolist()
+
+        for col in cols:
+            # df[col] = df[col].apply(lambda x: re.sub('[="]', '', str(x)) if '="' in str(x) else x)
+            # 百分比在某些数据库中不兼容, 转换百分比为小数
+            df[col] = df[col].apply(lambda x: float(float((str(x).rstrip("%"))) / 100) if str(x).endswith('%') and '~' not in str(x) else x)
+            # 尝试转换合适的数据类型
+            if df[col].dtype == 'object':
+                try:
+                    # df[col] = df[col].astype(int)  # 尝试转换 int
+                    df[col] = df[col].apply(lambda x: int(x) if '_' not in str(x) else x)
+                except:
+                    # df[col] = df[col].astype('float64', errors='ignore')    # 尝试转换 float, 报错则忽略
+                    try:
+                        df[col] = df[col].apply(lambda x: float(x) if '_' not in str(x) else x)
+                    except:
+                        pass
+            if df[col].dtype == 'float':  # 对于小数类型, 保留 6 位小数
+                df[col] = df[col].apply(lambda x: round(float(x), 6) if x != 0 else x)
+            # 清理列名, 在 mysql 里面列名不能含有某些特殊字符
+            if '日期' in col or '时间' in col:
+                try:
+                    df[col] = df[col].apply(lambda x: pd.to_datetime(x))
+                except:
+                    pass
+            new_col = col.lower()
+            df.rename(columns={col: new_col}, inplace=True)
+        df.fillna(0, inplace=True)
+        return df
+
+    def convert_df_cols_bak(self, df=pd.DataFrame({})):
         """
         清理 dataframe 列名的不合规字符(mysql)
         对数据类型进行转换(尝试将 object 类型转为 int 或 float)

mdbq/mysql/{data_types.py → data_types_/345/215/263/345/260/206/345/210/240/351/231/244.py}

@@ -49,13 +49,19 @@ class DataTypes:
                     '数据简介': '记录 dataframe 或者数据库的列信息(dtypes)',
                 }
         }
+        self.path = set_support.SetSupport(dirname='support').dirname
+        self.json_file = os.path.join(self.path, 'mysql_types.json')
+        if not os.path.isdir(self.path):
+            os.makedirs(self.path)
+        if not os.path.isfile(self.json_file):
+            with open(self.json_file, 'w', encoding='utf-8_sig') as f:
+                json.dump(self.datas, f, ensure_ascii=False, sort_keys=True, indent=4)
 
-    def json_before(self, json_file):
+    def json_before(self):
         """ 本地 json 文件的 dtypes 信息, 初始化更新给 self.datas """
-        if os.path.isfile(json_file):
-            with open(json_file, 'r', encoding='utf-8_sig') as f:
-                json_ = json.load(f)
-                self.datas.update(json_)
+        with open(self.json_file, 'r', encoding='utf-8_sig') as f:
+            json_ = json.load(f)
+            self.datas.update(json_)
 
     def df_dtypes_to_json(self, db_name, collection_name, path, df=pd.DataFrame(), is_file_dtype=True):
         if len(df) == 0:
@@ -148,7 +154,10 @@ class DataTypes:
             if os.path.isfile(json_file):
                 self.json_before(json_file=json_file)
             else:
-                print(f'不存在的文件: {json_file}')
+                # 如果不存在，则新建文件
+                with open(json_file, 'w', encoding='utf-8_sig') as f:
+                    json.dump(self.datas, f, ensure_ascii=False, sort_keys=True, indent=4)
+                # print(f'不存在的文件: {json_file}')
                 return
 
         if cl in self.datas.keys():
@@ -170,7 +179,7 @@ def mysql_all_dtypes(path=None):
     """
     更新笔记本 mysql 中所有数据库的 dtypes 信息到本地 json
     """
-    if not os.path.isdir(path):
+    if not path:
         path = set_support.SetSupport(dirname='support').dirname
 
     username, password, host, port = get_myconf.select_config_values(target_service='home_lx', database='mysql')
@@ -229,4 +238,6 @@ def mysql_all_dtypes(path=None):
 
 
 if __name__ == '__main__':
-    mysql_all_dtypes()  # 更新 mysql 中所有数据库的 dtypes 信息到本地 json
+    # mysql_all_dtypes()  # 更新 mysql 中所有数据库的 dtypes 信息到本地 json
+    d = DataTypes()
+

mdbq/mysql/mysql.py

@@ -9,13 +9,14 @@ import warnings
 import pymysql
 import numpy as np
 import pandas as pd
+from more_itertools.more import iequals
 from sqlalchemy import create_engine
 import os
 import calendar
 from mdbq.config import get_myconf
 from mdbq.config import set_support
 from mdbq.dataframe import converter
-from mdbq.mysql import data_types
+from mdbq.aggregation import mysql_types
 
 warnings.filterwarnings('ignore')
 
@@ -34,153 +35,106 @@ class MysqlUpload:
             'charset': charset,  # utf8mb4 支持存储四字节的UTF-8字符集
             'cursorclass': pymysql.cursors.DictCursor,
         }
-        self.conn = None
 
-    @staticmethod
-    def try_except(func):  # 在类内部定义一个异常处理方法
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            try:
-                return func(*args, **kwargs)
-            except Exception as e:
-                print(f'{func.__name__}, {e}')  # 将异常信息返回
-
-        return wrapper
-
-    def _conn(self):
-        self.config = {
-            'host': self.host,
-            'port': int(self.port),
-            'user': self.username,
-            'password': self.password,
-            'charset': 'utf8mb4',  # utf8mb4 支持存储四字节的UTF-8字符集
-            'cursorclass': pymysql.cursors.DictCursor,
-        }
-        try:
-            self.conn = pymysql.connect(**self.config)  # 连接数据库
-            return True
-        except:
-            return False
-
-    # @try_except
-    def df_to_mysql(self, df, tabel_name, db_name='远程数据源'):
+    def df_to_mysql(self, df, tabel_name, db_name='远程数据源', drop_duplicates=False):
         """
         将 df 写入数据库
         db_name: 数据库名称
         tabel_name: 集合/表名称
+        drop_duplicates：仅限于聚合数据使用，其他情况不要设置
         """
-        db_name = re.sub(r'[\',，（）()/=<>+\-*^"’\[\]~#|&% .]', '_', db_name)
-        tabel_name = re.sub(r'[\',，（）()/=<>+\-*^"’\[\]~#|&% .]', '_', tabel_name)
         cv = converter.DataFrameConverter()
-        df = cv.convert_df_cols(df=df)  # 清理列名中的不合规字符
+        df = cv.convert_df_cols(df=df)  # 清理 dataframe 非法值
 
         connection = pymysql.connect(**self.config)  # 连接数据库
-        try:
-            with connection.cursor() as cursor:
-                cursor.execute(f"SHOW DATABASES LIKE '{db_name}'")  # 检查数据库是否存在
-                database_exists = cursor.fetchone()
-                if not database_exists:
-                    # 如果数据库不存在，则新建
-                    if '8.138.27' in str(self.host) or platform.system() == "Linux":  # 阿里云 mysql 低版本不支持 0900
-                        cursor.execute(f"CREATE DATABASE {db_name} COLLATE utf8mb4_unicode_ci")
-                        self.config.update({'charset': 'utf8mb4_unicode_ci'})
-                    if '192.168.1.100' in str(self.host):
-                        cursor.execute(f"CREATE DATABASE {db_name}")
-                    else:
-                        cursor.execute(f"CREATE DATABASE {db_name} COLLATE utf8mb4_0900_ai_ci")
-                    # cursor.execute(f"CREATE DATABASE {db_name}")
-                    connection.commit()
-                    print(f"创建Database: {db_name}")
-        except Exception as e:
-            print(e)
-            return
-        finally:
-            connection.close()  # 这里要断开连接
-            time.sleep(0.2)
+        with connection.cursor() as cursor:
+            cursor.execute(f"SHOW DATABASES LIKE '{db_name}'")  # 检查数据库是否存在
+            database_exists = cursor.fetchone()
+            if not database_exists:
+                # 如果数据库不存在，则新建
+                if '8.138.27' in str(self.host) or platform.system() == "Linux":  # 阿里云 mysql 低版本不支持 0900
+                    sql = f"CREATE DATABASE `{db_name}` COLLATE utf8mb4_unicode_ci"
+                    self.config.update({'charset': 'utf8mb4_unicode_ci'})
+                if '192.168.1.100' in str(self.host):
+                    sql = f"CREATE DATABASE `{db_name}`"
+                else:
+                    sql = f"CREATE DATABASE `{db_name}` COLLATE utf8mb4_0900_ai_ci"
+                cursor.execute(sql)
+                connection.commit()
+                print(f"创建Database: {db_name}")
 
         self.config.update({'database': db_name})  # 添加更新 config 字段
         connection = pymysql.connect(**self.config)  # 重新连接数据库
-        try:
-            with connection.cursor() as cursor:
-                tabel_name = tabel_name.replace('-', '_')
-                # 1. 查询表, 不存在则创建一个空表
-                cursor.execute(f"SHOW TABLES LIKE '{tabel_name}'")
-                if not cursor.fetchone():
-                    sql = f'CREATE TABLE IF NOT EXISTS {tabel_name} (id INT AUTO_INCREMENT PRIMARY KEY)'
-                    cursor.execute(sql)
-                    print(f'创建 mysql 表: {tabel_name}')
-
-                # # 2. 列数据类型转换
-                # cols = df.columns.tolist()
-                # dtypes = df.dtypes.apply(str).to_dict()  # 将 dataframe 数据类型转为字典形式
-                # # 转换为 mysql 的数据类型
-                # dtypes.update({col: self.convert_dtype_to_sql(df=df, col=col, dtype=dtypes[col]) for col in cols})
-                dtypes = self.convert_dtypes(df=df, db_name=db_name, tabel_name=tabel_name)
-
-                # 3. 检查列, 不存在则添加新列
-                cols = df.columns.tolist()
-                for col in cols:
-                    sql = ('SELECT 1 FROM information_schema.columns WHERE table_schema = %s AND table_name = %s AND '
-                           'column_name = %s')
-                    cursor.execute(sql, (db_name, {tabel_name}, col))
-                    if cursor.fetchone() is None:  # 如果列不存在，添加新列
-                        print(f"添加列: {col}({dtypes[col]})")  # 添加列并指定数据类型
-                        # if col == '日期':
-                        #     sql = f"ALTER TABLE {tabel_name} ADD COLUMN {col} DATE default NULL;"
-                        # else:
-                        #     sql = f"ALTER TABLE {tabel_name} ADD COLUMN {col} mediumtext default NULL;"
-                        sql = f"ALTER TABLE {tabel_name} ADD COLUMN {col} {dtypes[col]} default NULL;"
-                        cursor.execute(sql)
+        with connection.cursor() as cursor:
+            # 1. 查询表, 不存在则创建一个空表
+            sql = f"SHOW TABLES LIKE '{tabel_name}';"  # 有特殊字符不需转义
+            cursor.execute(sql)
+            if not cursor.fetchone():
+                sql = f"CREATE TABLE IF NOT EXISTS `{tabel_name}` (id INT AUTO_INCREMENT PRIMARY KEY)"
+                cursor.execute(sql)
+                print(f'创建 mysql 表: {tabel_name}')
 
-                    if col == '日期':
-                        cursor.execute(f"SHOW INDEXES FROM `{tabel_name}` WHERE Column_name = %s", ({col},))
-                        result = cursor.fetchone()  # 检查索引是否存在
-                        if not result:
-                            # print(f'创建索引: {col}')
-                            cursor.execute(f"CREATE INDEX index_name ON {tabel_name}({col})")
-                connection.commit()  # 提交事务
-
-                # # 4. 移除指定日期范围内的数据, 避免重复插入
-                # dates = df['日期'].values.tolist()
-                # start_date = pd.to_datetime(min(dates)).strftime('%Y-%m-%d')
-                # end_date = (pd.to_datetime(max(dates)) + datetime.timedelta(days=1)).strftime('%Y-%m-%d')
-                # sql = f"DELETE FROM {tabel_name} WHERE {'日期'} BETWEEN '%s' AND '%s'" % (start_date, end_date)
-                # cursor.execute(sql)
-                # connection.commit()
-
-                # 5. 更新插入数据
-                now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
-                print(f'{now}正在更新 mysql ({self.host}:{self.port}) {db_name}/{tabel_name}')
-                if str(self.host) == '192.168.1.100':  # 群晖服务器
-                    try:
-                        datas = df.to_dict('records')
-                        for data in datas:
-                            cols = ', '.join(data.keys())
-                            values = ', '.join([f'"{v}"' for v in data.values()])
-                            sql = f"INSERT INTO {tabel_name} ({cols}) VALUES ({values})"
-                            cursor.execute(sql)
-                        connection.commit()
-                    except Exception as e:
-                        print(e)
-                        connection.rollback()
-                else:  # 其他服务器
+            # 2. 列数据类型转换，将 df 数据类型转换为 mysql 的数据类型
+            dtypes = self.convert_dtypes(df=df, db_name=db_name, tabel_name=tabel_name)
+
+            #  有特殊字符不需转义
+            sql = f"SELECT COLUMN_NAME FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_SCHEMA = '{db_name}' AND TABLE_NAME = '{tabel_name}';"
+            cursor.execute(sql)
+            col_exist = [item['COLUMN_NAME'] for item in cursor.fetchall()]
+            cols = df.columns.tolist()
+            col_not_exist = [col for col in cols if col not in col_exist]
+            # 检查列，不存在则新建列
+            if col_not_exist:  # 数据表中不存在的列
+                for col in col_not_exist:
                     try:
-                        engine = create_engine(
-                            f'mysql+pymysql://{self.username}:{self.password}@{self.host}:{self.port}/{db_name}'
-                        )
-                        df.to_sql(tabel_name, con=engine, if_exists='append', index=False)
-                    except Exception as e:  # 如果异常则回滚
-                        try:
-                            connection.rollback()
-                            print(f'{e}, 发生异常，正在重试...')
-                            # df = df.replace([np.inf, -np.inf], 0)
-                            df.to_sql(tabel_name, con=engine, if_exists='append', index=False)
-                        except Exception as e:
-                            now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
-                            print(f'{now}{db_name}/{tabel_name}数据异常, 正在回滚: {e}')
-                            connection.rollback()
-        finally:
-            connection.close()
+                        #  创建列，需转义
+                        sql = f"ALTER TABLE `{tabel_name}` ADD COLUMN `{col}` {dtypes[col]} DEFAULT NULL;"
+                        cursor.execute(sql)
+                        print(f"添加列: {col}({dtypes[col]})")  # 添加列并指定数据类型
+
+                        # 创建索引
+                        if col == '日期':
+                            cursor.execute(f"SHOW INDEXES FROM `{tabel_name}` WHERE `Column_name` = '{col}'")
+                            result = cursor.fetchone()  # 检查索引是否存在
+                            if not result:
+                                cursor.execute(f"CREATE INDEX index_name ON `{tabel_name}`(`{col}`)")
+                    except:
+                        pass
+            connection.commit()  # 提交事务
+
+            # 4. 移除指定日期范围内的数据，仅限于聚合数据使用，其他情况不要设置
+            if drop_duplicates and '日期' in df.columns.tolist():
+                dates = df['日期'].values.tolist()
+                start_date = pd.to_datetime(min(dates)).strftime('%Y-%m-%d')
+                end_date = (pd.to_datetime(max(dates)) + datetime.timedelta(days=1)).strftime('%Y-%m-%d')
+                sql = f"DELETE FROM `{tabel_name}` WHERE {'日期'} BETWEEN '%s' AND '%s'" % (start_date, end_date)
+                cursor.execute(sql)
+                connection.commit()
+
+            # 5. 更新插入数据
+            now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
+            print(f'{now}正在更新 mysql ({self.host}:{self.port}) {db_name}/{tabel_name}')
+            datas = df.to_dict(orient='records')
+            for data in datas:
+                try:
+                    cols = ', '.join(f"`{item}`" for item in data.keys())  # 列名转义
+                    # data.update({item: f"{data[item]}" for item in data.keys()})  # 全部值转字符, 不是必须的
+                    values = ', '.join([f"'{item}'" for item in data.values()])  # 值要加单引号 ''
+                    condition = []
+                    for k, v in data.items():
+                        condition += [f"`{k}` = '{v}'"]
+                    condition = ' AND '.join(condition)  # 构建查询条件
+                    # print(condition)
+
+                    sql = f"SELECT {cols} FROM `{tabel_name}` WHERE {condition}"
+                    cursor.execute(sql)
+                    result = cursor.fetchall()  # 获取查询结果, 如果有结果返回 list，没有则返回空元组 tuple
+                    if not result:  # 数据不存在则插入
+                        sql = f"INSERT INTO `{tabel_name}` ({cols}) VALUES ({values});"
+                        cursor.execute(sql)
+                except:
+                    pass
+        connection.commit()  # 提交事务
 
     def convert_dtypes(self, df, db_name, tabel_name):
         """
@@ -191,12 +145,10 @@ class MysqlUpload:
         2. json 文件中没有或者缺失部分列信息(利用 convert_dtype_to_sql 函数按指定规则转换缺失列)
         """
         cols = df.columns.tolist()
-        path = set_support.SetSupport(dirname='support').dirname
-        # json_file = os.path.join(path, 'mysql_types.json')
-        # if os.path.isfile(json_file):
-        d = data_types.DataTypes()
+        # path = set_support.SetSupport(dirname='support').dirname
+        d = mysql_types.DataTypes()
         # 从本地文件中读取 dtype 信息
-        dtypes = d.load_dtypes(cl='mysql', db_name=db_name, collection_name=tabel_name, path=path)
+        dtypes = d.load_dtypes(cl='mysql', db_name=db_name, tabel_name=tabel_name)
         # 可能会因为没有 json 文件, 返回 None
         if dtypes:
             # 按照文件记录更新 dtypes
@@ -205,7 +157,7 @@ class MysqlUpload:
             col_not_exist = [col for col in cols if col not in dtypes.keys()]
             # 这些列不存在于 df 中, 必须移除
             [dtypes.pop(col) for col in list(dtypes.keys()) if col not in cols]
-        else:
+        else:  # 没有 json 文件时
             dtypes = df.dtypes.apply(str).to_dict()  # 将 dataframe 数据类型转为字典形式
             col_not_exist = cols
         # 对文件不存在的列信息进行数据类型转换(按指定规则)
@@ -240,61 +192,12 @@ class MysqlUpload:
                 return 'mediumtext'
             return 'INT'
         elif dtype == 'float64':
-            return 'FLOAT'
+            return 'double'  # mysql 中不要使用 float 类型，会影响计算结果
         elif dtype == 'object':
             return 'mediumtext'
         else:
             return 'mediumtext'
 
-    def upload_pandas(self, update_path, db_name, days=None):
-        """
-        专门用来上传 pandas数据源的全部文件,  跳过 '其他数据'  or '京东数据集'
-        db_name: 数据库名: pandas数据源
-        update_path: pandas数据源所在路径
-        days: 更新近期数据，单位: 天, 不设置则全部更新
-        """
-        if days:
-            today = datetime.date.today()
-            start_date = pd.to_datetime(today - datetime.timedelta(days=days))
-        else:
-            start_date = pd.to_datetime('2000-01-01')
-
-        root_files = os.listdir(update_path)
-        for root_file in root_files:
-            if '其他数据' in root_file or '年.csv' in root_file or '京东数据集' in root_file:
-                continue  # 跳过的文件夹
-            f_path = os.path.join(update_path, root_file)
-
-            if os.path.isdir(f_path):
-                for root, dirs, files in os.walk(f_path, topdown=False):
-                    for name in files:
-                        if name.endswith('.csv') and 'baidu' not in name:
-                            df = pd.read_csv(os.path.join(root, name), encoding='utf-8_sig', header=0, na_filter=False)
-                            # if '日期' not in df.columns.tolist():
-                            #     now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
-                            #     print(f'{now}{root_file} 缺少日期列, 不支持上传 mysql')
-                            #     continue
-                            if '日期' in df.columns.tolist():
-                                df['日期'] = df['日期'].apply(lambda x: pd.to_datetime(x) if x else x)
-                                df = df[df['日期'] >= start_date]
-                            if len(df) == 0:
-                                continue
-                            self.df_to_mysql(df=df, db_name=db_name, tabel_name=root_file)
-            elif os.path.isfile(f_path):
-                if f_path.endswith('.csv') and 'baidu' not in f_path:
-                    df = pd.read_csv(f_path, encoding='utf-8_sig', header=0, na_filter=False)
-                    # if '日期' not in df.columns.tolist():
-                    #     now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
-                    #     print(f'{now}{root_file} 缺少日期列, 不支持上传 mysql')
-                    #     continue
-                    if '日期' not in df.columns.tolist():
-                        df['日期'] = df['日期'].apply(lambda x: pd.to_datetime(x) if x else x)
-                        df = df[df['日期'] >= start_date]
-                    if len(df) == 0:
-                        continue
-                    table = f'{os.path.splitext(root_file)[0]}_f'  # 这里定义了文件表会加 _f 后缀
-                    self.df_to_mysql(df=df, db_name=db_name, tabel_name=table)
-
     # @try_except
     def read_mysql(self, tabel_name, start_date, end_date, db_name='远程数据源', ):
         start_date = pd.to_datetime(start_date).strftime('%Y-%m-%d')
@@ -345,6 +248,55 @@ class MysqlUpload:
             print(f'{now}mysql ({self.host}) 表: {tabel_name} 获取数据长度: {len(df)}, 用时: {cost_time} 秒')
         return df
 
+    def upload_pandas(self, update_path, db_name, days=None):
+        """
+        专门用来上传 pandas数据源的全部文件,  跳过 '其他数据'  or '京东数据集'
+        db_name: 数据库名: pandas数据源
+        update_path: pandas数据源所在路径
+        days: 更新近期数据，单位: 天, 不设置则全部更新
+        """
+        if days:
+            today = datetime.date.today()
+            start_date = pd.to_datetime(today - datetime.timedelta(days=days))
+        else:
+            start_date = pd.to_datetime('2000-01-01')
+
+        root_files = os.listdir(update_path)
+        for root_file in root_files:
+            if '其他数据' in root_file or '年.csv' in root_file or '京东数据集' in root_file:
+                continue  # 跳过的文件夹
+            f_path = os.path.join(update_path, root_file)
+
+            if os.path.isdir(f_path):
+                for root, dirs, files in os.walk(f_path, topdown=False):
+                    for name in files:
+                        if name.endswith('.csv') and 'baidu' not in name:
+                            df = pd.read_csv(os.path.join(root, name), encoding='utf-8_sig', header=0, na_filter=False)
+                            # if '日期' not in df.columns.tolist():
+                            #     now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
+                            #     print(f'{now}{root_file} 缺少日期列, 不支持上传 mysql')
+                            #     continue
+                            if '日期' in df.columns.tolist():
+                                df['日期'] = df['日期'].apply(lambda x: pd.to_datetime(x) if x else x)
+                                df = df[df['日期'] >= start_date]
+                            if len(df) == 0:
+                                continue
+                            self.df_to_mysql(df=df, db_name=db_name, tabel_name=root_file)
+            elif os.path.isfile(f_path):
+                if f_path.endswith('.csv') and 'baidu' not in f_path:
+                    df = pd.read_csv(f_path, encoding='utf-8_sig', header=0, na_filter=False)
+                    # if '日期' not in df.columns.tolist():
+                    #     now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S ")
+                    #     print(f'{now}{root_file} 缺少日期列, 不支持上传 mysql')
+                    #     continue
+                    if '日期' not in df.columns.tolist():
+                        df['日期'] = df['日期'].apply(lambda x: pd.to_datetime(x) if x else x)
+                        df = df[df['日期'] >= start_date]
+                    if len(df) == 0:
+                        continue
+                    table = f'{os.path.splitext(root_file)[0]}_f'  # 这里定义了文件表会加 _f 后缀
+                    self.df_to_mysql(df=df, db_name=db_name, tabel_name=table)
+
 
 class OptimizeDatas:
     """
@@ -689,8 +641,13 @@ def download_datas(tabel_name, save_path, start_date):
 
 
 if __name__ == '__main__':
-    username, password, host, port = get_myconf.select_config_values(target_service='home_lx', database='mysql')
+    username, password, host, port = get_myconf.select_config_values(target_service='company', database='mysql')
     print(username, password, host, port)
 
+    df = pd.read_csv('/Users/xigua/Downloads/余额查询.csv', encoding='utf-8_sig', header=0, na_filter=False)
+    # df = df.to_dict(orient='records')
+    m = MysqlUpload(username=username, password=password, host=host, port=port)
+    m.df_to_mysql_new(df=df, db_name='te2- %s t', tabel_name='测 -sdf @%试 表')
+
 
 

{mdbq-0.4.5.dist-info → mdbq-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mdbq
-Version: 0.4.5
+Version: 1.0.0
 Home-page: https://pypi.org/project/mdbsql
 Author: xigua, 
 Author-email: 2587125111@qq.com

{mdbq-0.4.5.dist-info → mdbq-1.0.0.dist-info}/RECORD

@@ -1,9 +1,11 @@
 mdbq/__init__.py,sha256=Il5Q9ATdX8yXqVxtP_nYqUhExzxPC_qk_WXQ_4h0exg,16
 mdbq/__version__.py,sha256=y9Mp_8x0BCZSHsdLT_q5tX9wZwd5QgqrSIENLrb6vXA,62
 mdbq/aggregation/__init__.py,sha256=EeDqX2Aml6SPx8363J-v1lz0EcZtgwIBYyCJV6CcEDU,40
-mdbq/aggregation/aggregation.py,sha256=6j6gl0fiHuNtepP-NM38h_-1v_3a62AFtH_a55NXjq0,58254
+mdbq/aggregation/aggregation.py,sha256=1myTHs_OwFngpf1_qFfC9l9CJKpLAVg8X9fO6at-3XY,53064
+mdbq/aggregation/df_types.py,sha256=T35KML0sdch8GzIwo7CxSIrt72YVElBeCrsKQx4dX_0,7531
+mdbq/aggregation/mysql_types.py,sha256=-dJbc7FJ0L0czjb2M55x11oy0AnwlKnrSkArUjoIFo0,9705
 mdbq/aggregation/optimize_data.py,sha256=jLAWtxPUuhpo4XTVrhKtT4xK3grs7r73ePQfLhxlu1I,779
-mdbq/aggregation/query_data.py,sha256=0i9aF63O-E_SGdJ_09-pAOvAGOzJBIQOzv29dLlwruA,24491
+mdbq/aggregation/query_data.py,sha256=5lzvEokjHuKtlaSBYjOFH8VA2MTtX8R3MwEUNs03qKg,24491
 mdbq/bdup/__init__.py,sha256=AkhsGk81SkG1c8FqDH5tRq-8MZmFobVbN60DTyukYTY,28
 mdbq/bdup/bdup.py,sha256=LAV0TgnQpc-LB-YuJthxb0U42_VkPidzQzAagan46lU,4234
 mdbq/clean/__init__.py,sha256=A1d6x3L27j4NtLgiFV5TANwEkLuaDfPHDQNrPBbNWtU,41
@@ -16,14 +18,14 @@ mdbq/config/products.py,sha256=tFqSfFSXyZXcof0gAeHq0Ftn4F5i9ucoMyIqZ1H_D2Q,4260
 mdbq/config/set_support.py,sha256=LJLEbUFrv8y-GVskiwOI8A9uRaCEAUa0Yfjugt4yLp0,768
 mdbq/config/update_conf.py,sha256=taL3ZqKgiVWwUrDFuaYhim9a72Hm4BHRhhDscJTziR8,4535
 mdbq/dataframe/__init__.py,sha256=2HtCN8AdRj53teXDqzysC1h8aPL-mMFy561ESmhehGQ,22
-mdbq/dataframe/converter.py,sha256=h_BDc6oNmMCVFOUzZJq4nXNGDyJFJyycpWqlyrv7U04,3089
+mdbq/dataframe/converter.py,sha256=cD9u9eaDkOcxMaiZH6Wq_0Jp9PLsoPJOmrys7yZpGvI,5535
 mdbq/log/__init__.py,sha256=Mpbrav0s0ifLL7lVDAuePEi1hJKiSHhxcv1byBKDl5E,15
 mdbq/log/mylogger.py,sha256=oaT7Bp-Hb9jZt52seP3ISUuxVcI19s4UiqTeouScBO0,3258
 mdbq/mongo/__init__.py,sha256=SILt7xMtQIQl_m-ik9WLtJSXIVf424iYgCfE_tnQFbw,13
 mdbq/mongo/mongo.py,sha256=q0B4wXDSTtXg_vMN7MPh6zdxl6tT68tM74LmdVNQQek,31892
 mdbq/mysql/__init__.py,sha256=A_DPJyAoEvTSFojiI2e94zP0FKtCkkwKP1kYUCSyQzo,11
-mdbq/mysql/data_types.py,sha256=N7_SyRviE7H25grmMydLT3W3PLk6s3gIK4i36hut4Ms,9791
-mdbq/mysql/mysql.py,sha256=Dp9pXINt7H-FFmn84mpvOJQ41Y9i1CqrC_1lcWvYAQM,33607
+mdbq/mysql/data_types_即将删除.py,sha256=sjBBDKr9674LdjM5N_dwyJACdZPbdB8Beli59jGdgnQ,10378
+mdbq/mysql/mysql.py,sha256=51VBrxoIJo7z2Pw0SN-u1oJp8oWvRj87ULFmH0kJXN0,31914
 mdbq/mysql/s_query.py,sha256=6-8O9MHhi3-7n3isJ7t2kTCYL2mSBC_HrxSQmXM5UtI,7901
 mdbq/mysql/year_month_day.py,sha256=VgewoE2pJxK7ErjfviL_SMTN77ki8GVbTUcao3vFUCE,1523
 mdbq/other/__init__.py,sha256=jso1oHcy6cJEfa7udS_9uO5X6kZLoPBF8l3wCYmr5dM,18
@@ -34,7 +36,7 @@ mdbq/pbix/__init__.py,sha256=Trtfaynu9RjoTyLLYBN2xdRxTvm_zhCniUkVTAYwcjo,24
 mdbq/pbix/pbix_refresh.py,sha256=JUjKW3bNEyoMVfVfo77UhguvS5AWkixvVhDbw4_MHco,2396
 mdbq/pbix/refresh_all.py,sha256=tgy762608HMaXWynbOURIf2UVMuSPybzrDXQnOOcnZU,6102
 mdbq/spider/__init__.py,sha256=RBMFXGy_jd1HXZhngB2T2XTvJqki8P_Fr-pBcwijnew,18
-mdbq-0.4.5.dist-info/METADATA,sha256=ub_BDdxrKZ82aSIyKKOEqiD8cpigJs3Ivyh40UJqp-c,245
-mdbq-0.4.5.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
-mdbq-0.4.5.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
-mdbq-0.4.5.dist-info/RECORD,,
+mdbq-1.0.0.dist-info/METADATA,sha256=AcCveIBgct8lUzgMAxu2w5wVpfraRoiM4fECYC0QF30,245
+mdbq-1.0.0.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
+mdbq-1.0.0.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
+mdbq-1.0.0.dist-info/RECORD,,

{mdbq-0.4.5.dist-info → mdbq-1.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.44.0)
+Generator: setuptools (70.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any