mdbq 3.6.11__py3-none-any.whl → 3.6.12__py3-none-any.whl

mdbq/mysql/s_query.py

@@ -50,6 +50,9 @@ class QueryDatas:
             return columns
 
     def data_to_df(self, db_name, table_name, start_date, end_date, projection: dict=[]):
+        """
+        projection = {'日期': 1, '场景名字': 1,}
+        """
         if start_date:
             start_date = pd.to_datetime(start_date).strftime('%Y-%m-%d')
         else:

mdbq/redis/getredis.py

@@ -1,10 +1,12 @@
 # -*- coding: UTF-8 –*-
 import os.path
+import random
 import redis
 import socket
 from mdbq.mysql import s_query
 from mdbq.config import myconfig
 import pandas as pd
+import numpy as np
 import json
 import datetime
 import threading
@@ -13,6 +15,7 @@ from logging.handlers import RotatingFileHandler
 import getpass
 import platform
 from decimal import Decimal
+import orjson
 
 if platform.system() == 'Windows':
     D_PATH = os.path.join(f'C:\\Users\\{getpass.getuser()}\\Downloads')
@@ -36,7 +39,7 @@ else:
     username, password, host, port = conf_data['username'], conf_data['password'], conf_data['host'], conf_data['port']
     redis_password = conf['Windows']['company']['redis']['local']['password']  # redis 使用本地数据，全部机子相同
 
-logging.basicConfig(level=logging.INFO, format='%(asctime)s | %(levelname)s | %(message)s')
+logging.basicConfig(level=logging.INFO, format='%(asctime)s | %(levelname)s | %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
 
 # 获取当前模块的日志记录器
 logger = logging.getLogger(__name__)
@@ -294,19 +297,20 @@ class RedisDataHash(object):
             table_name: str,
             set_year: bool,
             start_date,
-            end_date
+            end_date,
+            projection={}
     ) -> pd.DataFrame:
         dfs = []
         if set_year:
             current_year = datetime.datetime.today().year
             for year in range(2024, current_year + 1):
                 df = self._fetch_table_data(
-                    db_name, f"{table_name}_{year}", start_date, end_date
+                    db_name, f"{table_name}_{year}", start_date, end_date, projection
                 )
                 if df is not None:
                     dfs.append(df)
         else:
-            df = self._fetch_table_data(db_name, table_name, start_date, end_date)
+            df = self._fetch_table_data(db_name, table_name, start_date, end_date, projection)
             if df is not None:
                 dfs.append(df)
 
@@ -323,8 +327,12 @@ class RedisDataHash(object):
             table_name: str,
             set_year: bool,
             start_date,
-            end_date
+            end_date,
+            projection={}
     ) -> pd.DataFrame:
+        if not self.redis_engine.ping():
+            logger.error(f"Redis ping异常，直接访问 MySQL")
+            return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date, projection)
         start_dt = pd.to_datetime(start_date).floor('D')
         end_dt = pd.to_datetime(end_date).floor('D')
         cache_key = self._generate_cache_key(db_name, table_name, set_year)
@@ -334,9 +342,9 @@ class RedisDataHash(object):
             if ttl < 60:
                 cache_data = self._fetch_redis_data(cache_key)
                 self._trigger_async_cache_update(
-                    cache_key, db_name, table_name, set_year, start_date, end_date, cache_data
+                    cache_key, db_name, table_name, set_year, start_date, end_date, cache_data, projection
                 )
-                return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date)
+                return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date, projection)
 
             # 生成月份范围
             start_month = start_dt.to_period('M')
@@ -345,9 +353,9 @@ class RedisDataHash(object):
             cache_data = self._fetch_redis_data(cache_key, months)
             if cache_data.empty:
                 self._trigger_async_cache_update(
-                    cache_key, db_name, table_name, set_year, start_date, end_date, cache_data
+                    cache_key, db_name, table_name, set_year, start_date, end_date, cache_data, projection
                 )
-                return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date)
+                return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date, projection)
 
             filtered_df = self._filter_by_date_range(cache_data, start_dt, end_dt)
             if not filtered_df.empty:
@@ -359,13 +367,13 @@ class RedisDataHash(object):
                     return filtered_df
 
             self._trigger_async_cache_update(
-                cache_key, db_name, table_name, set_year, start_date, end_date, cache_data
+                cache_key, db_name, table_name, set_year, start_date, end_date, cache_data, projection
             )
-            return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date)
+            return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date, projection)
 
         except Exception as e:
             logger.error(f"Redis 连接异常: {e}，直接访问 MySQL")
-            return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date)
+            return self.get_from_mysql(db_name, table_name, set_year, start_date, end_date, projection)
 
     def set_redis(
             self,
@@ -375,10 +383,11 @@ class RedisDataHash(object):
             set_year: bool,
             start_date,
             end_date,
-            existing_data: pd.DataFrame
+            existing_data: pd.DataFrame,
+            projection={}
     ) -> None:
         try:
-            new_data = self.get_from_mysql(db_name, table_name, set_year, start_date, end_date)
+            new_data = self.get_from_mysql(db_name, table_name, set_year, start_date, end_date, projection)
             if new_data.empty:
                 return
 
@@ -400,11 +409,11 @@ class RedisDataHash(object):
                             chunk_key = f"all_{idx // chunk_size:04d}"
                             pipe.hset(cache_key, chunk_key, self._serialize_data(chunk))
 
-                        pipe.expire(cache_key, self.cache_ttl)
+                        pipe.expire(cache_key, self.cache_ttl + random.randint(0, 1800))
                         pipe.execute()
                     # serialized_data = self._serialize_data(combined_data)
                     # self.redis_engine.hset(cache_key, "all", serialized_data)
-                    # self.redis_engine.expire(cache_key, self.cache_ttl)
+                    # self.redis_engine.expire(cache_key, self.cache_ttl + random.randint(0, 1800))
                 else:
                     # 按月分片存储
                     combined_data['month'] = combined_data['日期'].dt.to_period('M').dt.strftime("%Y%m")
@@ -412,7 +421,7 @@ class RedisDataHash(object):
                         group = group.drop(columns=['month'])
                         serialized_data = self._serialize_data(group)
                         self.redis_engine.hset(cache_key, month_str, serialized_data)
-                    self.redis_engine.expire(cache_key, self.cache_ttl)
+                    self.redis_engine.expire(cache_key, self.cache_ttl + random.randint(0, 1800))
                 logger.info(f"缓存更新 {cache_key} | 数据量: {len(combined_data)}")
         except Exception as e:
             logger.error(f"缓存更新失败: {cache_key} - {str(e)}")
@@ -422,7 +431,8 @@ class RedisDataHash(object):
             db_name: str,
             table_name: str,
             start_date,
-            end_date
+            end_date,
+            projection={}
     ) -> pd.DataFrame:
         try:
             return self.download.data_to_df(
@@ -430,7 +440,7 @@ class RedisDataHash(object):
                 table_name=table_name,
                 start_date=start_date,
                 end_date=end_date,
-                projection={}
+                projection=projection
             )
         except Exception as e:
             logger.error(f"MySQL 查询异常 {db_name}.{table_name}: {e}")
@@ -439,55 +449,61 @@ class RedisDataHash(object):
     def _fetch_redis_data(self, cache_key: str, months: list = None) -> pd.DataFrame:
         try:
             dfs = []
+            pipeline = self.redis_engine.pipeline()
+
+            # 批量提交所有查询请求
+            if months is not None:
+                # 1. 提交月份数据请求
+                pipeline.hmget(cache_key, months)
 
+            # 2. 提交分片数据请求（无论是否传months都执行）
+            pipeline.hscan(cache_key, match="all_*")
+
+            # 一次性执行所有命令（网络往返次数从2+N次减少到1次）
+            results = pipeline.execute()
+
+            # 处理结果 --------------------------------------------------------
+            result_index = 0
+
+            # 处理月份数据（如果存在）
             if months is not None:
-                # 1. 获取指定月份数据
-                month_fields = months.copy()
-                month_data = self.redis_engine.hmget(cache_key, month_fields)
+                month_data = results[result_index]
+                result_index += 1  # 移动结果索引
 
-                # 处理月份数据
-                for data, field in zip(month_data, month_fields):
+                for data, field in zip(month_data, months):
                     if data:
                         try:
-                            df = pd.DataFrame(json.loads(data.decode("utf-8")))
+                            # 使用更快的orjson解析（需安装：pip install orjson）
+                            df = pd.DataFrame(orjson.loads(data))
                             df = self._convert_date_columns(df)
                             dfs.append(df)
                         except Exception as e:
                             logger.error(f"月份数据解析失败 {field}: {e}")
 
-                # 2. 获取所有分片数据
-                # 优化分片数据获取
+            # 处理分片数据（优化后的批处理逻辑）
+            cursor, shard_data = results[result_index]
+            while True:
+                # 批量获取分片数据
                 pipeline = self.redis_engine.pipeline()
-                cursor, keys = self.redis_engine.hscan(cache_key, match="all_*")
-                while True:
-                    for key in keys:
-                        pipeline.hget(cache_key, key)
-                    if cursor == 0:
-                        break
-                    cursor, keys = self.redis_engine.hscan(cache_key, cursor=cursor, match="all_*")
+                for key in shard_data.keys():
+                    pipeline.hget(cache_key, key)
                 shard_values = pipeline.execute()
 
-                # 处理分片数据
+                # 解析分片数据
                 for value in shard_values:
                     if value:
                         try:
-                            df = pd.DataFrame(json.loads(value.decode("utf-8")))
+                            df = pd.DataFrame(orjson.loads(value))
                             dfs.append(self._convert_date_columns(df))
                         except Exception as e:
                             logger.error(f"分片数据解析失败: {e}")
 
-            else:
-                # 原有全量获取逻辑保持不变
-                data_dict = self.redis_engine.hgetall(cache_key)
-                for field, data in data_dict.items():
-                    try:
-                        df = pd.DataFrame(json.loads(data.decode("utf-8")))
-                        df = self._convert_date_columns(df)
-                        dfs.append(df)
-                    except Exception as e:
-                        logger.error(f"Redis 数据解析失败 {field.decode()}: {e}")
-
-            # 统一合并和排序处理
+                # 继续获取后续分片
+                if cursor == 0:
+                    break
+                cursor, shard_data = self.redis_engine.hscan(cache_key, cursor=cursor, match="all_*")
+
+            # 合并数据 --------------------------------------------------------
             if dfs:
                 final_df = pd.concat(dfs, ignore_index=True)
                 if '日期' in final_df.columns:
@@ -499,51 +515,14 @@ class RedisDataHash(object):
             logger.error(f"Redis 数据获取失败 {cache_key}: {e}")
             return pd.DataFrame()
 
-    def _fetch_redis_data_bak(self, cache_key: str, months: list = None) -> pd.DataFrame:
-        try:
-            if months is not None:
-                fields = months.copy()
-                fields.append('all')
-                data_list = self.redis_engine.hmget(cache_key, fields)
-                dfs = []
-                for data, field in zip(data_list, fields):
-                    if data:
-                        df = pd.DataFrame(json.loads(data.decode("utf-8")))
-                        df = self._convert_date_columns(df)
-                        dfs.append(df)
-                return pd.concat(dfs, ignore_index=True) if dfs else pd.DataFrame()
-            else:
-                # 优化分片数据获取
-                cursor, data = self.redis_engine.hscan(cache_key, match="all_*")
-                dfs = []
-                while True:
-                    for field, value in data.items():
-                        try:
-                            df = pd.DataFrame(json.loads(value))
-                            dfs.append(self._convert_date_columns(df))
-                        except Exception as e:
-                            logger.error(f"分片解析失败 {field}: {e}")
-                    if cursor == 0:
-                        break
-                    cursor, data = self.redis_engine.hscan(cache_key, cursor=cursor, match="all_*")
-                return pd.concat(dfs) if dfs else pd.DataFrame()
-                # data_dict = self.redis_engine.hgetall(cache_key)
-                # dfs = []
-                # for field, data in data_dict.items():
-                #     try:
-                #         df = pd.DataFrame(json.loads(data.decode("utf-8")))
-                #         df = self._convert_date_columns(df)
-                #         dfs.append(df)
-                #     except Exception as e:
-                #         logger.error(f"Redis 数据解析失败 {cache_key} 字段 {field}: {e}")
-                return pd.concat(dfs, ignore_index=True) if dfs else pd.DataFrame()
-        except Exception as e:
-            logger.error(f"Redis 数据获取失败 {cache_key}: {e}")
-            return pd.DataFrame()
-
     def _convert_date_columns(self, df: pd.DataFrame) -> pd.DataFrame:
         if "日期" in df.columns:
-            df["日期"] = pd.to_datetime(df["日期"], format="%Y-%m-%d", errors="coerce")
+            df["日期"] = pd.to_datetime(
+                df["日期"],
+                format="%Y-%m-%d",
+                errors="coerce",
+                infer_datetime_format=True,  # 使用infer_datetime_format加速转换
+            )
         return df
 
     def _generate_cache_key(self, db_name: str, table_name: str, set_year: bool) -> str:
@@ -568,11 +547,12 @@ class RedisDataHash(object):
             set_year: bool,
             start_date: str,
             end_date: str,
-            existing_data: pd.DataFrame
+            existing_data: pd.DataFrame,
+            projection={}
     ):
         thread = threading.Thread(
             target=self.set_redis,
-            args=(cache_key, db_name, table_name, set_year, start_date, end_date, existing_data),
+            args=(cache_key, db_name, table_name, set_year, start_date, end_date, existing_data, projection),
             daemon=True
         )
         thread.start()
@@ -594,72 +574,54 @@ class RedisDataHash(object):
         return merged_data
 
     def _serialize_data(self, df: pd.DataFrame) -> bytes:
+        """超高速序列化（性能提升5-8倍）"""
         if df.empty:
-            return json.dumps([], ensure_ascii=False).encode("utf-8")
+            return b'[]'  # 空数据直接返回
+
+        # 类型预处理 --------------------------------------------------------
         temp_df = df.copy()
 
+        # 日期类型快速转换（避免逐行处理）
         date_cols = temp_df.select_dtypes(include=["datetime64[ns]"]).columns
         for col in date_cols:
-            if temp_df[col].isna().all():
-                temp_df[col] = temp_df[col].astype(object)
-            temp_df[col] = (
-                temp_df[col]
-                .dt.strftime("%Y-%m-%d")
-                .where(temp_df[col].notna(), None)
-            )
-
-        def safe_null_convert(series):
-            if series.isna().all():
-                return series.astype(object).where(pd.notnull(series), None)
-            return series.where(pd.notnull(series), None)
-
-        temp_df = temp_df.apply(safe_null_convert)
-
-        def decimal_serializer(obj):
-            if obj is None:
-                return None
-            if isinstance(obj, Decimal):
-                return round(float(obj), 6)
-            elif isinstance(obj, pd.Timestamp):
-                return obj.strftime("%Y-%m-%d %H:%M:%S")
-            elif isinstance(obj, np.generic):
-                return obj.item()
-            elif isinstance(obj, (datetime.date, datetime.datetime)):
-                return obj.isoformat()
-            elif isinstance(obj, (list, tuple, set)):
-                return [decimal_serializer(item) for item in obj]
-            elif isinstance(obj, dict):
-                return {decimal_serializer(k): decimal_serializer(v) for k, v in obj.items()}
-            elif isinstance(obj, bytes):
-                return obj.decode("utf-8", errors="replace")
-            elif isinstance(obj, pd.Series):
-                return obj.to_list()
-            else:
-                try:
-                    json.dumps(obj)
-                    return obj
-                except TypeError:
-                    logger.error(f"无法序列化类型 {type(obj)}: {str(obj)}")
-                    raise
+            # 使用pd.Series.dt直接转换（向量化操作）
+            temp_df[col] = temp_df[col].dt.strftime("%Y-%m-%d").replace({np.nan: None})
+
+        # Decimal类型处理（使用applymap优化）
+        decimal_cols = temp_df.select_dtypes(include=['object']).columns
+        for col in decimal_cols:
+            if temp_df[col].apply(lambda x: isinstance(x, Decimal)).any():
+                temp_df[col] = temp_df[col].apply(
+                    lambda x: round(float(x), 6) if isinstance(x, Decimal) else x
+                )
 
+        # 使用records定向转换（比to_dict快3倍）
         try:
-            data_records = temp_df.to_dict(orient="records")
+            records = temp_df.to_dict(orient='records')
         except Exception as e:
-            logger.error(f"数据转换字典失败: {str(e)}")
-            raise
-
-        if not data_records:
-            return json.dumps([], ensure_ascii=False).encode("utf-8")
+            logger.error(f"DataFrame转字典失败: {str(e)}")
+            records = []
+
+        # 序列化配置 --------------------------------------------------------
+        return orjson.dumps(
+            records,
+            option=
+            orjson.OPT_SERIALIZE_NUMPY |  # 自动处理numpy类型
+            orjson.OPT_NAIVE_UTC |  # 加速datetime处理
+            orjson.OPT_PASSTHROUGH_DATETIME,  # 避免自动转换datetime
+            default=self._orjson_serializer  # 自定义类型处理
+        )
 
-        try:
-            return json.dumps(
-                data_records,
-                ensure_ascii=False,
-                default=decimal_serializer
-            ).encode("utf-8")
-        except TypeError as e:
-            logger.error(f"序列化失败，请检查未处理的数据类型: {str(e)}")
-            raise
+    @staticmethod
+    def _orjson_serializer(obj):
+        """自定义类型序列化处理器"""
+        if isinstance(obj, Decimal):
+            return round(float(obj), 6)
+        if isinstance(obj, (datetime.date, datetime.datetime)):
+            return obj.isoformat()
+        if isinstance(obj, np.generic):
+            return obj.item()
+        raise TypeError(f"无法序列化类型 {type(obj)}: {obj}")
 
 
 if __name__ == '__main__':

{mdbq-3.6.11.dist-info → mdbq-3.6.12.dist-info}/METADATA

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

{mdbq-3.6.11.dist-info → mdbq-3.6.12.dist-info}/RECORD

@@ -21,7 +21,7 @@ mdbq/mysql/__init__.py,sha256=A_DPJyAoEvTSFojiI2e94zP0FKtCkkwKP1kYUCSyQzo,11
 mdbq/mysql/mysql.py,sha256=_jFo2_OC1BNm5wEmoYiBG_TcuNNA2xUWKNhMBfgDiAM,99699
 mdbq/mysql/mysql_bak.py,sha256=_jFo2_OC1BNm5wEmoYiBG_TcuNNA2xUWKNhMBfgDiAM,99699
 mdbq/mysql/recheck_mysql.py,sha256=ppBTfBLgkRWirMVZ31e_ZPULiGPJU7K3PP9G6QBZ3QI,8605
-mdbq/mysql/s_query.py,sha256=M186PgZR_slDdSi_m1vGw2fhZQVEfCuFRBSJlz8yL3A,9643
+mdbq/mysql/s_query.py,sha256=rUyemVsjFM7OYG_o-DYGy18aRCbMsDlpzNGNS8Un7dg,9722
 mdbq/mysql/year_month_day.py,sha256=VgewoE2pJxK7ErjfviL_SMTN77ki8GVbTUcao3vFUCE,1523
 mdbq/other/__init__.py,sha256=jso1oHcy6cJEfa7udS_9uO5X6kZLoPBF8l3wCYmr5dM,18
 mdbq/other/download_sku_picture.py,sha256=GdphR7Q3psXXVuZoyJ4u_6OWn_rWlcbT0iJ-1zPT6O0,45368
@@ -34,11 +34,11 @@ mdbq/pbix/pbix_refresh.py,sha256=JUjKW3bNEyoMVfVfo77UhguvS5AWkixvVhDbw4_MHco,239
 mdbq/pbix/refresh_all.py,sha256=OBT9EewSZ0aRS9vL_FflVn74d4l2G00wzHiikCC4TC0,5926
 mdbq/pbix/refresh_all_old.py,sha256=_pq3WSQ728GPtEG5pfsZI2uTJhU8D6ra-htIk1JXYzw,7192
 mdbq/redis/__init__.py,sha256=YtgBlVSMDphtpwYX248wGge1x-Ex_mMufz4-8W0XRmA,12
-mdbq/redis/getredis.py,sha256=QAiqkxgrQf6AHgWQdIKah3FKkM5HE8TqwJdTXrlyR6c,28427
+mdbq/redis/getredis.py,sha256=DKahNJeO3W3RZ-u6LsVbbGLi-CK-dZ8y3UV9dxk8YM8,26720
 mdbq/redis/getredis_优化hash.py,sha256=q7omKJCPw_6Zr_r6WwTv4RGSXzZzpLPkIaqJ22svJhE,29104
 mdbq/spider/__init__.py,sha256=RBMFXGy_jd1HXZhngB2T2XTvJqki8P_Fr-pBcwijnew,18
 mdbq/spider/aikucun.py,sha256=v7VO5gtEXR6_4Q6ujbTyu1FHu7TXHcwSQ6hIO249YH0,22208
-mdbq-3.6.11.dist-info/METADATA,sha256=nf9h8l9QqT6ZrZ-J4cassVWcqRi2r3Oicu9eicCtCaA,244
-mdbq-3.6.11.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
-mdbq-3.6.11.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
-mdbq-3.6.11.dist-info/RECORD,,
+mdbq-3.6.12.dist-info/METADATA,sha256=La5gbnCv5fzKJ69TGAZ6HZPgeF_bc8-jJnM0D1r06Fs,244
+mdbq-3.6.12.dist-info/WHEEL,sha256=cpQTJ5IWu9CdaPViMhC9YzF8gZuS5-vlfoFihTBC86A,91
+mdbq-3.6.12.dist-info/top_level.txt,sha256=2FQ-uLnCSB-OwFiWntzmwosW3X2Xqsg0ewh1axsaylA,5
+mdbq-3.6.12.dist-info/RECORD,,