update redis-key format

config.py

@@ -207,158 +207,165 @@ class BaseConfig(object):
     P = 0.3
     P_18_19 = 1
 
-    # ROV召回池redis key前缀，完整格式：com.weiqu.video.recall.hot.item.score.{date}
+    # 小程序离线ROV模型结果存放 redis key前缀，完整格式：recall:item:score:rov:{date}
-    RECALL_KEY_NAME_PREFIX = 'com.weiqu.video.recall.hot.item.score.'
+    RECALL_KEY_NAME_PREFIX = 'recall:item:score:rov:'
-
+
-    # 小程序小时级更新结果存放 redis key前缀，完整格式：com.weiqu.video.recall.item.score.h.{rule_key}.{date}.{h}
+    # # 小程序小时级更新结果存放 redis key前缀，完整格式：com.weiqu.video.recall.item.score.h.{rule_key}.{date}.{h}
-    RECALL_KEY_NAME_PREFIX_BY_H = 'com.weiqu.video.recall.item.score.h.'
+    # RECALL_KEY_NAME_PREFIX_BY_H = 'com.weiqu.video.recall.item.score.h.'
-    # 小程序相对24h数据更新结果与 小程序小时级更新结果 去重后 存放 redis key前缀，
+    # # 小程序相对24h数据更新结果与 小程序小时级更新结果 去重后 存放 redis key前缀，
-    # 完整格式：com.weiqu.video.recall.hot.item.score.dup.24h.h.{rule_key}.{date}.{h}
+    # # 完整格式：com.weiqu.video.recall.hot.item.score.dup.24h.h.{rule_key}.{date}.{h}
-    RECALL_KEY_NAME_PREFIX_DUP_24H_H = 'com.weiqu.video.recall.hot.item.score.dup.24h.h.'
+    # RECALL_KEY_NAME_PREFIX_DUP_24H_H = 'com.weiqu.video.recall.hot.item.score.dup.24h.h.'
-    # 小程序离线ROV模型结果与小程序小时级更新结果去重后 存放 redis key前缀，
+    # # 小程序离线ROV模型结果与小程序小时级更新结果去重后 存放 redis key前缀，
-    # 完整格式：com.weiqu.video.recall.hot.item.score.dup.h.{rule_key}{date}.{h}
+    # # 完整格式：com.weiqu.video.recall.hot.item.score.dup.h.{rule_key}{date}.{h}
-    RECALL_KEY_NAME_PREFIX_DUP_H = 'com.weiqu.video.recall.hot.item.score.dup.h.'
+    # RECALL_KEY_NAME_PREFIX_DUP_H = 'com.weiqu.video.recall.hot.item.score.dup.h.'
-
+
-    # 每个mid存储对应小时级更新结果 redis key前缀，完整格式：com.weiqu.video.recall.hot.item.score.h.mid.{appType}.{mid}
+    # # 每个mid存储对应小时级更新结果 redis key前缀，完整格式：com.weiqu.video.recall.hot.item.score.h.mid.{appType}.{mid}
-    H_WITH_MID_RECALL_KEY_NAME_PREFIX = 'com.weiqu.video.recall.hot.item.score.h.mid.'
+    # H_WITH_MID_RECALL_KEY_NAME_PREFIX = 'com.weiqu.video.recall.hot.item.score.h.mid.'
-    # 记录 mid-小时级key 中数据所属(date，h)，完整格式：com.weiqu.video.h.record.mid.{appType}.{mid}
+    # # 记录 mid-小时级key 中数据所属(date，h)，完整格式：com.weiqu.video.h.record.mid.{appType}.{mid}
-    H_WITH_MID_RECORD_KEY_NAME_PREFIX = 'com.weiqu.video.h.record.mid.'
+    # H_WITH_MID_RECORD_KEY_NAME_PREFIX = 'com.weiqu.video.h.record.mid.'
-
+    #
-    # 每个mid存储对应小时级更新结果 redis key前缀，完整格式：com.weiqu.video.recall.hot.item.score.h.24h.mid.{appType}.{mid}
+    # # 每个mid存储对应小时级更新结果 redis key前缀，完整格式：com.weiqu.video.recall.hot.item.score.h.24h.mid.{appType}.{mid}
-    H_WITH_MID_RECALL_KEY_NAME_PREFIX_24H = 'com.weiqu.video.recall.hot.item.score.h.24h.mid.'
+    # H_WITH_MID_RECALL_KEY_NAME_PREFIX_24H = 'com.weiqu.video.recall.hot.item.score.h.24h.mid.'
-    # 记录 mid-小时级key 中数据所属(date，h)，完整格式：com.weiqu.video.h.24h.record.mid.{appType}.{mid}
+    # # 记录 mid-小时级key 中数据所属(date，h)，完整格式：com.weiqu.video.h.24h.record.mid.{appType}.{mid}
-    H_WITH_MID_RECORD_KEY_NAME_PREFIX_24H = 'com.weiqu.video.h.24h.record.mid.'
+    # H_WITH_MID_RECORD_KEY_NAME_PREFIX_24H = 'com.weiqu.video.h.24h.record.mid.'
-
+    #
-    # 每个mid存储对应小时级更新结果 redis key前缀，完整格式：com.weiqu.video.recall.hot.item.score.h.region.24h.mid.{appType}.{mid}
+    # # 每个mid存储对应小时级更新结果 redis key前缀，完整格式：com.weiqu.video.recall.hot.item.score.h.region.24h.mid.{appType}.{mid}
-    H_WITH_MID_RECALL_KEY_NAME_PREFIX_REGION_24H = 'com.weiqu.video.recall.hot.item.score.h.region.24h.mid.'
+    # H_WITH_MID_RECALL_KEY_NAME_PREFIX_REGION_24H = 'com.weiqu.video.recall.hot.item.score.h.region.24h.mid.'
-    # 记录 mid-小时级key 中数据所属(date，h)，完整格式：com.weiqu.video.h.region.24h.record.mid.{appType}.{mid}
+    # # 记录 mid-小时级key 中数据所属(date，h)，完整格式：com.weiqu.video.h.region.24h.record.mid.{appType}.{mid}
-    H_WITH_MID_RECORD_KEY_NAME_PREFIX_REGION_24H = 'com.weiqu.video.h.region.24h.record.mid.'
+    # H_WITH_MID_RECORD_KEY_NAME_PREFIX_REGION_24H = 'com.weiqu.video.h.region.24h.record.mid.'
-
+
-    # 用户上一次在 地域分组小时级 更新列表中对应的位置 redis key前缀，完整key格式：video.region.h.last.item.{appType}.{mid}
+    # 用户上一次在 地域分组小时级 更新列表中对应的位置 redis key前缀，完整key格式：recall:pool:last:item:region:h:{appType}:{mid}
-    LAST_VIDEO_FROM_REGION_H_PREFIX = 'video.region.h.last.item.'
+    LAST_VIDEO_FROM_REGION_H_PREFIX = 'recall:last:item:region:h:'
-    # 记录 mid-上一次在 地域分组小时级 更新列表中对应的位置key 中数据所属(date，h)，完整格式：video.region.h.last.record.mid.{appType}.{mid}
+    # 记录 mid-上一次在 地域分组小时级 更新列表中对应的位置key 中数据所属(date，h)，完整格式：recall:pool:last:record:region:h:{appType}:{mid}
-    RECORD_KEY_NAME_PREFIX_LAST_VIDEO_REGION_H = 'video.region.h.last.record.mid.'
+    RECORD_KEY_NAME_PREFIX_LAST_VIDEO_REGION_H = 'recall:last:record:region:h:'
-
+
-    # 用户上一次在dup1 分地域24h更新列表中对应的位置 redis key前缀，完整key格式：video.region.dup1.24h.last.item.{appType}.{mid}
+    # 用户上一次在dup1 分地域24h更新列表中对应的位置 redis key前缀，完整key格式：recall:last:item:region:dup1:24h:{appType}:{mid}
-    LAST_VIDEO_FROM_REGION_DUP1_24H_PREFIX = 'video.region.dup1.24h.last.item.'
+    LAST_VIDEO_FROM_REGION_DUP1_24H_PREFIX = 'recall:last:item:region:dup1:24h:'
-    # 记录 mid-上一次在dup1 分地域24h更新列表中对应的位置key 中数据所属(date，h)，完整格式：video.region.dup1.24h.last.record.mid.{appType}.{mid}
+    # 记录 mid-上一次在dup1 分地域24h更新列表中对应的位置key 中数据所属(date，h)，完整格式：recall:last:record:region:dup1:24h:{appType}:{mid}
-    RECORD_KEY_NAME_PREFIX_LAST_VIDEO_REGION_DUP1_24H = 'video.region.dup1.24h.last.record.mid.'
+    RECORD_KEY_NAME_PREFIX_LAST_VIDEO_REGION_DUP1_24H = 'recall:last:record:region:dup1:24h:'
-
+
-    # 用户上一次在dup2 24h更新列表中对应的位置 redis key前缀，完整key格式：video.region.dup2.24h.last.item.{appType}.{mid}
+    # 用户上一次在dup2 24h更新列表中对应的位置 redis key前缀，完整key格式：recall:last:item:region:dup2:24h:{appType}:{mid}
-    LAST_VIDEO_FROM_REGION_DUP2_24H_PREFIX = 'video.region.dup2.24h.last.item.'
+    LAST_VIDEO_FROM_REGION_DUP2_24H_PREFIX = 'recall:last:item:region:dup2:24h:'
-    # 记录 mid-上一次在dup2 24h更新列表中对应的位置key 中数据所属(date，h)，完整格式：video.region.dup2.24h.last.record.mid.{appType}.{mid}
+    # 记录 mid-上一次在dup2 24h更新列表中对应的位置key 中数据所属(date，h)，完整格式：recall:last:record:region:dup2:24h:{appType}:{mid}
-    RECORD_KEY_NAME_PREFIX_LAST_VIDEO_REGION_DUP2_24H = 'video.region.dup2.24h.last.record.mid.'
+    RECORD_KEY_NAME_PREFIX_LAST_VIDEO_REGION_DUP2_24H = 'recall:last:record:region:dup2:24h:'
-
+
-    # 用户上一次在dup3 24h更新列表中对应的位置 redis key前缀，完整key格式：video.region.dup3.24h.last.item.{appType}.{mid}
+    # 用户上一次在dup3 24h更新列表中对应的位置 redis key前缀，完整key格式：recall:last:item:region:dup3:24h:{appType}:{mid}
-    LAST_VIDEO_FROM_REGION_DUP3_24H_PREFIX = 'video.region.dup3.24h.last.item.'
+    LAST_VIDEO_FROM_REGION_DUP3_24H_PREFIX = 'recall:last:item:region:dup3:24h:'
-    # 记录 mid-上一次在dup3 24h更新列表中对应的位置key 中数据所属(date，h)，完整格式：video.region.dup3.24h.last.record.mid.{appType}.{mid}
+    # 记录 mid-上一次在dup3 24h更新列表中对应的位置key 中数据所属(date，h)，完整格式：recall:last:record:region:dup2:24h:{appType}:{mid}
-    RECORD_KEY_NAME_PREFIX_LAST_VIDEO_REGION_DUP3_24H = 'video.region.dup3.24h.last.record.mid.'
+    RECORD_KEY_NAME_PREFIX_LAST_VIDEO_REGION_DUP3_24H = 'recall:last:record:region:dup3:24h:'
-
+
-    # 小时级视频状态不符合推荐要求的列表 redis key，完整格式：com.weiqu.video.filter.h.item.{rule_key}
+    # # 小时级视频状态不符合推荐要求的列表 redis key，完整格式：com.weiqu.video.filter.h.item.{rule_key}
-    H_VIDEO_FILER = 'com.weiqu.video.filter.h.item.'
+    # H_VIDEO_FILER = 'com.weiqu.video.filter.h.item.'
-
+
-    # 小程序天级更新结果存放 redis key前缀，完整格式：com.weiqu.video.recall.item.score.day.{rule_key}.{date}
+    # # 小程序天级更新结果存放 redis key前缀，完整格式：com.weiqu.video.recall.item.score.day.{rule_key}.{date}
-    RECALL_KEY_NAME_PREFIX_BY_DAY = 'com.weiqu.video.recall.item.score.day.'
+    # RECALL_KEY_NAME_PREFIX_BY_DAY = 'com.weiqu.video.recall.item.score.day.'
-    # 小程序离线ROV模型结果与小程序天级更新结果去重后 存放 redis key前缀，
+    # # 小程序离线ROV模型结果与小程序天级更新结果去重后 存放 redis key前缀，
-    # 完整格式：com.weiqu.video.recall.hot.item.score.dup.day.now.{rule_key}.{date}
+    # # 完整格式：com.weiqu.video.recall.hot.item.score.dup.day.now.{rule_key}.{date}
-    RECALL_KEY_NAME_PREFIX_DUP_DAY_NOW = 'com.weiqu.video.recall.hot.item.score.dup.day.now.'
+    # RECALL_KEY_NAME_PREFIX_DUP_DAY_NOW = 'com.weiqu.video.recall.hot.item.score.dup.day.now.'
-    # 使用前一天小程序离线ROV模型结果与小程序天级更新结果去重后 存放 redis key前缀，
+    # # 使用前一天小程序离线ROV模型结果与小程序天级更新结果去重后 存放 redis key前缀，
-    # 完整格式：com.weiqu.video.recall.hot.item.score.dup.day.pre.{rule_key}.{date}
+    # # 完整格式：com.weiqu.video.recall.hot.item.score.dup.day.pre.{rule_key}.{date}
-    RECALL_KEY_NAME_PREFIX_DUP_DAY_PRE = 'com.weiqu.video.recall.hot.item.score.dup.day.pre.'
+    # RECALL_KEY_NAME_PREFIX_DUP_DAY_PRE = 'com.weiqu.video.recall.hot.item.score.dup.day.pre.'
-
+
-    # 小程序小时级24h数据更新结果存放 redis key前缀，
+    # # 小程序小时级24h数据更新结果存放 redis key前缀，
-    # 完整格式：com.weiqu.video.recall.item.score.apptype.24h.{appType}.{data_key}.{rule_key}.{date}.{h}
+    # # 完整格式：com.weiqu.video.recall.item.score.apptype.24h.{appType}.{data_key}.{rule_key}.{date}.{h}
-    RECALL_KEY_NAME_PREFIX_BY_24H = 'com.weiqu.video.recall.item.score.apptype.24h.'
+    # RECALL_KEY_NAME_PREFIX_BY_24H = 'com.weiqu.video.recall.item.score.apptype.24h.'
-    # 小程序离线ROV模型结果与小程序小时级24h更新结果去重后 存放 redis key前缀，
+    # # 小程序离线ROV模型结果与小程序小时级24h更新结果去重后 存放 redis key前缀，
-    # 完整格式：com.weiqu.video.recall.hot.item.score.dup.24h.{rule_key}.{date}.{h}
+    # # 完整格式：com.weiqu.video.recall.hot.item.score.dup.24h.{rule_key}.{date}.{h}
-    RECALL_KEY_NAME_PREFIX_DUP_24H = 'com.weiqu.video.recall.hot.item.score.dup.24h.'
+    # RECALL_KEY_NAME_PREFIX_DUP_24H = 'com.weiqu.video.recall.hot.item.score.dup.24h.'
-    # 小时级视频状态不符合推荐要求的列表 redis key，完整格式：com.weiqu.video.filter.apptype.h.item.24h.{appType}.{data_key}.{rule_key}
+    # # 小时级视频状态不符合推荐要求的列表 redis key，完整格式：com.weiqu.video.filter.apptype.h.item.24h.{appType}.{data_key}.{rule_key}
-    H_VIDEO_FILER_24H = 'com.weiqu.video.filter.apptype.h.item.24h.'
+    # H_VIDEO_FILER_24H = 'com.weiqu.video.filter.apptype.h.item.24h.'
 
     # 小程序地域分组小时级更新结果存放 redis key前缀，
-    # 完整格式：com.weiqu.video.recall.item.score.apptype.region.h.{region}.{appType}.{data_key}.{rule_key}.{date}.{h}
+    # 完整格式：recall:item:score:apptype:region:h:{region}:{appType}:{data_key}:{rule_key}:{date}:{h}
-    RECALL_KEY_NAME_PREFIX_REGION_BY_H = 'com.weiqu.video.recall.item.score.apptype.region.h.'
+    RECALL_KEY_NAME_PREFIX_REGION_BY_H = 'recall:item:score:apptype:region:h:'
+
     # 小程序地域分组天级更新结果与小程序地域分组小时级更新结果去重后 存放 redis key前缀，
     # 完整格式：com.weiqu.video.recall.hot.item.score.dup1.region.day.h.{region}.{rule_key}.{date}.{h}
-    RECALL_KEY_NAME_PREFIX_DUP1_REGION_DAY_H = 'com.weiqu.video.recall.hot.item.score.dup1.region.day.h.'
+    # RECALL_KEY_NAME_PREFIX_DUP1_REGION_DAY_H = 'com.weiqu.video.recall.hot.item.score.dup1.region.day.h.'
+
     # 小程序地域分组小时级更新24h结果与小程序地域分组小时级更新结果去重后 存放 redis key前缀，
-    # 完整格式：com.weiqu.video.recall.hot.item.score.dup1.apptype.region.24h.h.{region}.{appType}.{data_key}.{rule_key}.{date}.{h}
+    # 完整格式：recall:item:score:apptype:region:dup1:region24h:{region}:{appType}:{data_key}:{rule_key}:{date}:{h}
-    RECALL_KEY_NAME_PREFIX_DUP1_REGION_24H_H = 'com.weiqu.video.recall.hot.item.score.dup1.apptype.region.24h.h.'
+    RECALL_KEY_NAME_PREFIX_DUP1_REGION_24H_H = 'recall:item:score:apptype:region:dup1:region24h:'
+
     # 小程序天级更新结果与 小程序地域分组天级更新结果/小程序地域分组小时级更新结果 去重后 存放 redis key前缀，
     # 完整格式：com.weiqu.video.recall.hot.item.score.dup2.region.day.h.{region}.{rule_key}.{date}.{h}
-    RECALL_KEY_NAME_PREFIX_DUP2_REGION_DAY_H = 'com.weiqu.video.recall.hot.item.score.dup2.region.day.h.'
+    # RECALL_KEY_NAME_PREFIX_DUP2_REGION_DAY_H = 'com.weiqu.video.recall.hot.item.score.dup2.region.day.h.'
+
     # 小程序24h更新结果与 小程序地域分组24h更新结果/小程序地域分组小时级更新结果 去重后 存放 redis key前缀，
-    # 完整格式：com.weiqu.video.recall.hot.item.score.dup2.apptype.region.24h.h.{region}.{appType}.{data_key}.{rule_key}.{date}.{h}
+    # 完整格式：recall:item:score:apptype:region:dup2:24h:{region}:{appType}:{data_key}:{rule_key}:{date}:{h}
-    RECALL_KEY_NAME_PREFIX_DUP2_REGION_24H_H = 'com.weiqu.video.recall.hot.item.score.dup2.apptype.region.24h.h.'
+    RECALL_KEY_NAME_PREFIX_DUP2_REGION_24H_H = 'recall:item:score:apptype:region:dup2:24h:'
     # 小程序小时级24h数据 筛选后的剩余数据 更新结果 与 小程序24h更新结果/小程序地域分组24h更新结果/小程序地域分组小时级更新结果 去重后 存放 redis key前缀，
-    # 完整格式：com.weiqu.video.recall.hot.item.score.dup3.apptype.region.24h.h.{region}.{appType}.{data_key}.{rule_key}.{date}.{h}
+    # 完整格式：recall:item:score:apptype:region:dup3:24h:{region}:{appType}:{data_key}:{rule_key}:{date}:{h}
-    RECALL_KEY_NAME_PREFIX_DUP3_REGION_24H_H = 'com.weiqu.video.recall.hot.item.score.dup3.apptype.region.24h.h.'
+    RECALL_KEY_NAME_PREFIX_DUP3_REGION_24H_H = 'recall:item:score:apptype:region:dup3:24h:'
     # 小程序离线ROV模型结果与 小程序天级更新结果/小程序地域分组天级更新结果/小程序地域分组小时级更新结果 去重后 存放 redis key前缀，
-    # 完整格式：com.weiqu.video.recall.hot.item.score.dup.apptype.region.h.{region}.{appType}.{data_key}.{rule_key}.{date}.{h}
+    # 完整格式：recall:item:score:apptype:region:dup4:rov:{region}:{appType}:{data_key}:{rule_key}:{date}:{h}
-    RECALL_KEY_NAME_PREFIX_DUP_REGION_H = 'com.weiqu.video.recall.hot.item.score.dup.apptype.region.h.'
+    RECALL_KEY_NAME_PREFIX_DUP_REGION_H = 'recall:item:score:apptype:region:dup4:rov:'
+
     # 地域分组小时级视频状态不符合推荐要求的列表 redis key，
     # 完整格式：com.weiqu.video.filter.apptype.region.h.item.{region}.{appType}.{data_key}.{rule_key}
-    REGION_H_VIDEO_FILER = 'com.weiqu.video.filter.apptype.region.h.item.'
+    # REGION_H_VIDEO_FILER = 'com.weiqu.video.filter.apptype.region.h.item.'
 
-    # 小程序地域分组小时级更新24h结果存放 redis key前缀，
+    # # 小程序地域分组小时级更新24h结果存放 redis key前缀，
-    # 完整格式：com.weiqu.video.recall.item.score.apptype.region.24h.{region}.{appType}.{data_key}.{rule_key}.{date}.{h}
+    # # 完整格式：com.weiqu.video.recall.item.score.apptype.region.24h.{region}.{appType}.{data_key}.{rule_key}.{date}.{h}
-    RECALL_KEY_NAME_PREFIX_REGION_BY_24H = 'com.weiqu.video.recall.item.score.apptype.region.24h.'
+    # RECALL_KEY_NAME_PREFIX_REGION_BY_24H = 'com.weiqu.video.recall.item.score.apptype.region.24h.'
-    # 小程序天级更新结果与 小程序地域分组小时级更新24h结果 去重后 存放 redis key前缀，
+    # # 小程序天级更新结果与 小程序地域分组小时级更新24h结果 去重后 存放 redis key前缀，
-    # 完整格式：com.weiqu.video.recall.hot.item.score.dup.region.day.24h.{region}.{rule_key}.{date}.{h}
+    # # 完整格式：com.weiqu.video.recall.hot.item.score.dup.region.day.24h.{region}.{rule_key}.{date}.{h}
-    RECALL_KEY_NAME_PREFIX_DUP_REGION_DAY_24H = 'com.weiqu.video.recall.hot.item.score.dup.region.day.24h.'
+    # RECALL_KEY_NAME_PREFIX_DUP_REGION_DAY_24H = 'com.weiqu.video.recall.hot.item.score.dup.region.day.24h.'
-    # 小程序离线ROV模型结果与 小程序天级更新结果/小程序地域分组小时级更新24h结果 去重后 存放 redis key前缀，
+    # # 小程序离线ROV模型结果与 小程序天级更新结果/小程序地域分组小时级更新24h结果 去重后 存放 redis key前缀，
-    # 完整格式：com.weiqu.video.recall.hot.item.score.dup.region.24h.{region}.{rule_key}.{date}.{h}
+    # # 完整格式：com.weiqu.video.recall.hot.item.score.dup.region.24h.{region}.{rule_key}.{date}.{h}
-    RECALL_KEY_NAME_PREFIX_DUP_REGION_24H = 'com.weiqu.video.recall.hot.item.score.dup.region.24h.'
+    # RECALL_KEY_NAME_PREFIX_DUP_REGION_24H = 'com.weiqu.video.recall.hot.item.score.dup.region.24h.'
-    # 地域分组小时级更新24h视频状态不符合推荐要求的列表 redis key，
+    # # 地域分组小时级更新24h视频状态不符合推荐要求的列表 redis key，
-    # 完整格式：com.weiqu.video.filter.apptype.region.h.item.24h.{region}.{appType}.{data_key}.{rule_key}
+    # # 完整格式：com.weiqu.video.filter.apptype.region.h.item.24h.{region}.{appType}.{data_key}.{rule_key}
-    REGION_H_VIDEO_FILER_24H = 'com.weiqu.video.filter.apptype.region.h.item.24h.'
+    # REGION_H_VIDEO_FILER_24H = 'com.weiqu.video.filter.apptype.region.h.item.24h.'
 
-    # app应用 小程序离线ROV模型结果存放 redis key前缀，完整格式：com.weiqu.video.recall.hot.item.score.app.{date}
+    # app应用 小程序离线ROV模型结果存放 redis key前缀，完整格式：recall:item:score:rov:app:{date}
-    RECALL_KEY_NAME_PREFIX_APP = 'com.weiqu.video.recall.hot.item.score.app.'
+    RECALL_KEY_NAME_PREFIX_APP = 'recall:item:score:rov:app:'
 
-    # app应用 小时级数据更新最终结果存放 redis key前缀，完整格式：com.weiqu.video.recall.hot.item.score.app.{date}.{h}
+    # # app应用 小时级数据更新最终结果存放 redis key前缀，完整格式：com.weiqu.video.recall.hot.item.score.app.{date}.{h}
-    APP_FINAL_RECALL_KEY_NAME_PREFIX = 'com.weiqu.video.recall.hot.item.score.app.'
+    # APP_FINAL_RECALL_KEY_NAME_PREFIX = 'com.weiqu.video.recall.hot.item.score.app.'
 
-    # appType:[18, 19]小程序离线ROV模型结果存放 redis key前缀，完整格式：com.weiqu.video.recall.hot.item.score.{appType}.{date}.{h}
+    # appType:[18, 19]小程序离线ROV模型结果存放 redis key前缀，完整格式：recall:item:score:{appType}:{date}:{h}
-    RECALL_KEY_NAME_PREFIX_APP_TYPE = 'com.weiqu.video.recall.hot.item.score.'
+    RECALL_KEY_NAME_PREFIX_APP_TYPE = 'recall:item:score:'
 
-    # 小程序老视频更新结果存放 redis key 前缀，完整格式：'com.weiqu.video.recall.old.item.{date}'
+    # # 小程序老视频更新结果存放 redis key 前缀，完整格式：'com.weiqu.video.recall.old.item.{date}'
-    RECALL_KEY_NAME_PREFIX_OLD_VIDEOS = 'com.weiqu.video.recall.old.item.'
+    # RECALL_KEY_NAME_PREFIX_OLD_VIDEOS = 'com.weiqu.video.recall.old.item.'
 
     # appType = 6, ROV召回池redis key前缀，完整格式：com.weiqu.video.recall.hot.apptype.h.item.score.6.{h}
     # RECALL_KEY_NAME_PREFIX_APP_TYPE = 'com.weiqu.video.recall.hot.apptype.h.item.score.6.'
 
-    # 流量池redis key前缀，完整格式 com.weiqu.video.flowpool.hot.item.score.{appType}
+    # 流量池离线模型结果存放 redis key前缀，完整格式 flow:pool:item:score:{appType}
-    FLOW_POOL_KEY_NAME_PREFIX = 'com.weiqu.video.flowpool.hot.item.score.'
+    FLOWPOOL_KEY_NAME_PREFIX = 'flow:pool:item:score:'
-    # 快速曝光流量池数据存放 redis key前缀，完整格式 com.weiqu.video.quick.flowpool.hot.item.score.{appType}.{flowPool_id}
+    # 快速曝光流量池数据存放 redis key前缀，完整格式 flow:pool:quick:item:score:{appType}:{flowPool_id}
-    QUICK_FLOWPOOL_KEY_NAME_PREFIX = 'com.weiqu.video.quick.flowpool.hot.item.score.'
+    QUICK_FLOWPOOL_KEY_NAME_PREFIX = 'flow:pool:quick:item:score:'
-    # 快速曝光流量池分发概率 redis key前缀，完整格式 com.weiqu.video.quick.flowpool.distribute_rate.{flowPool_id}
+    # 快速曝光流量池分发概率 redis key前缀，完整格式 flow:pool:quick:distribute:rate:{flowPool_id}
-    QUICK_FLOWPOOL_DISTRIBUTE_RATE_KEY_NAME_PREFIX = 'com.weiqu.video.quick.flowpool.distribute_rate.'
+    QUICK_FLOWPOOL_DISTRIBUTE_RATE_KEY_NAME_PREFIX = 'flow:pool:quick:distribute:rate:'
 
     # 修改ROV的视频 redis key
-    UPDATE_ROV_KEY_NAME = 'com.weiqu.video.update.rov.item.score'
+    UPDATE_ROV_KEY_NAME = 'update:rov:item:score:applet'
-    UPDATE_ROV_KEY_NAME_APP = 'com.weiqu.video.update.rov.item.score.app'
+    UPDATE_ROV_KEY_NAME_APP = 'update:rov:item:score:app'
-
+
-    # 首页推荐预曝光列表redis key 前缀，完整key格式：com.weiqu.video.hot.recommend.previewed.{appType}.{mid}
+    # 首页推荐预曝光列表redis key 前缀，完整key格式：previewed:videos:{appType}:{mid}
-    PREVIEW_KEY_PREFIX = 'com.weiqu.video.hot.recommend.previewed.'
+    PREVIEW_KEY_PREFIX = 'previewed:videos:'
-
+
-    # 用户上一次在rov召回池对应的位置 redis key前缀，完整key格式：com.weiqu.video.rov.pool.last.{appType}.{mid}.{date}
+    # 用户上一次在rov召回池对应的位置 redis key前缀，完整key格式：recall:pool:last:rov:{appType}:{mid}:{date}
-    LAST_VIDEO_FROM_ROV_POOL_PREFIX = 'com.weiqu.video.rov.pool.last.'
+    LAST_VIDEO_FROM_ROV_POOL_PREFIX = 'recall:last:rov:'
-    # 用户上一次在天级规则更新列表中对应的位置 redis key前缀，完整key格式：com.weiqu.video.rov.pool.last.{appType}.{mid}.{date}
+
-    LAST_VIDEO_FROM_RULE_DAY_POOL_PREFIX = 'com.weiqu.video.rule.day.pool.last.'
+    # # 用户上一次在天级规则更新列表中对应的位置 redis key前缀，完整key格式：com.weiqu.video.rov.pool.last.{appType}.{mid}.{date}
-    # 用户上一次在rov召回池对应的位置 redis key前缀，完整key格式：com.weiqu.video.rov.pool.last.pre.{appType}.{mid}.{date}
+    # LAST_VIDEO_FROM_RULE_DAY_POOL_PREFIX = 'com.weiqu.video.rule.day.pool.last.'
-    LAST_VIDEO_FROM_ROV_POOL_PRE_PREFIX = 'com.weiqu.video.rov.pool.last.pre.'
+    # # 用户上一次在rov召回池对应的位置 redis key前缀，完整key格式：com.weiqu.video.rov.pool.last.pre.{appType}.{mid}.{date}
-    # 用户上一次在rov召回池对应的位置 redis key前缀，完整key格式：com.weiqu.video.rov.pool.last.now.{appType}.{mid}.{date}
+    # LAST_VIDEO_FROM_ROV_POOL_PRE_PREFIX = 'com.weiqu.video.rov.pool.last.pre.'
-    LAST_VIDEO_FROM_ROV_POOL_NOW_PREFIX = 'com.weiqu.video.rov.pool.last.now.'
+    # # 用户上一次在rov召回池对应的位置 redis key前缀，完整key格式：com.weiqu.video.rov.pool.last.now.{appType}.{mid}.{date}
-    # 用户上一次在region dup更新列表中对应的位置 redis key前缀，完整key格式：com.weiqu.video.region.dup.last.{dup}.{appType}.{mid}.{date}
+    # LAST_VIDEO_FROM_ROV_POOL_NOW_PREFIX = 'com.weiqu.video.rov.pool.last.now.'
-    LAST_VIDEO_FROM_REGION_DUP_PREFIX = 'com.weiqu.video.region.dup.last.'
+    # # 用户上一次在region dup更新列表中对应的位置 redis key前缀，完整key格式：com.weiqu.video.region.dup.last.{dup}.{appType}.{mid}.{date}
-    # 用户上一次在完整影视资源列表对应的位置 redis key前缀，完整key格式：com.weiqu.video.whole.movies.last.{appType}.{mid}.{date}
+    # LAST_VIDEO_FROM_REGION_DUP_PREFIX = 'com.weiqu.video.region.dup.last.'
-    LAST_VIDEO_FROM_WHOLE_MOVIES_PREFIX = 'com.weiqu.video.whole.movies.last.'
+    # # 用户上一次在完整影视资源列表对应的位置 redis key前缀，完整key格式：com.weiqu.video.whole.movies.last.{appType}.{mid}.{date}
-
+    # LAST_VIDEO_FROM_WHOLE_MOVIES_PREFIX = 'com.weiqu.video.whole.movies.last.'
-    # 本地记录视频的可分发数，控制分发，完整key格式：com.weiqu.video.flowpool.local.distribute.count.{h}
+
-    # LOCAL_DISTRIBUTE_COUNT_PREFIX = 'com.weiqu.video.flowpool.local.distribute.count.'
+    # 用户上一次在特殊视频列表对应的位置 redis key前缀，完整key格式：recall:pool:last:special:{appType}:{mid}:{date}
-    # 本地记录视频的可分发数，控制分发，完整key格式：com.weiqu.video.flowpool.local.distribute.count.{videoId}.{flowPool}
+    LAST_VIDEO_FROM_SPECIAL_POOL_PREFIX = 'recall:last:special:'
-    LOCAL_DISTRIBUTE_COUNT_PREFIX = 'com.weiqu.video.flowpool.local.distribute.count.'
+
+    # 本地记录视频的可分发数，控制分发，完整key格式：flow:pool:local:distribute:count:{videoId}:{flowPool}
+    LOCAL_DISTRIBUTE_COUNT_PREFIX = 'flow:pool:local:distribute:count:'
 
     # 从ROV召回池获取视频的最大频次，限制每次请求的获取次数
     MAX_FREQ_FROM_ROV_POOL = 2
@@ -368,37 +375,37 @@ class BaseConfig(object):
     MAX_FREQ_FROM_FLOW_POOL_18_19 = 3
 
     # 兜底视频redis存储key
-    BOTTOM_KEY_NAME = 'com.weiqu.video.bottom'
+    BOTTOM_KEY_NAME = 'bottom:videos'
 
     # 生效中的置顶视频列表 redis key
-    TOP_VIDEO_LIST_KEY_NAME = 'com.weiqu.video.top.item.score.area'
+    TOP_VIDEO_LIST_KEY_NAME = 'top:item:score:area:applet'
-    TOP_VIDEO_LIST_KEY_NAME_APP = 'com.weiqu.video.top.item.score.area.app'
+    TOP_VIDEO_LIST_KEY_NAME_APP = 'top:item:score:area:app'
-
+
-    # 按位置排序redis存储key
+    # # 按位置排序redis存储key
-    RECALL_POSITION1_KEY_NAME = 'com.weiqu.video.recall.hot.apptype.h.item.score.position.1'
+    # RECALL_POSITION1_KEY_NAME = 'com.weiqu.video.recall.hot.apptype.h.item.score.position.1'
-    RECALL_POSITION2_KEY_NAME = 'com.weiqu.video.recall.hot.apptype.h.item.score.position.2'
+    # RECALL_POSITION2_KEY_NAME = 'com.weiqu.video.recall.hot.apptype.h.item.score.position.2'
-
+
-    # rov召回池更新时间
+    # # rov召回池更新时间
-    ROV_UPDATE_H = 6
+    # ROV_UPDATE_H = 6
-    ROV_UPDATE_MINUTE = 30
+    # ROV_UPDATE_MINUTE = 30
-
+    #
-    # 小时级召回池更新时间 每个小时的15分更新成功
+    # # 小时级召回池更新时间 每个小时的15分更新成功
-    ROV_H_UPDATE_MINUTE = 25
+    # ROV_H_UPDATE_MINUTE = 25
-
+    #
-    # 地域分组小时级召回池更新时间
+    # # 地域分组小时级召回池更新时间
-    REGION_H_UPDATE_MINUTE = 30
+    # REGION_H_UPDATE_MINUTE = 30
-
+    #
-    # 天级规则更新列表更新时间 00:30更新成功
+    # # 天级规则更新列表更新时间 00:30更新成功
-    ROV_DAY_UPDATE_MINUTE = 0
+    # ROV_DAY_UPDATE_MINUTE = 0
 
     # 置顶视频区域 为 全部 的code
     ALL_AREA_CODE = '000000'
 
-    # width : height > 1 的视频列表 redis key, zset存储，value为videoId，score为w_h_rate
+    # # width : height > 1 的视频列表 redis key, zset存储，value为videoId，score为w_h_rate
-    W_H_RATE_UP_1_VIDEO_LIST_KEY_NAME = {
+    # W_H_RATE_UP_1_VIDEO_LIST_KEY_NAME = {
-        'rov_recall': 'com.weiqu.video.rov.w.h.rate.1.item',  # rov召回池视频
+    #     'rov_recall': 'com.weiqu.video.rov.w.h.rate.1.item',  # rov召回池视频
-        'bottom_last': 'com.weiqu.video.bottom.last.w.h.rate.1.item'  # 二次兜底视频
+    #     'bottom_last': 'com.weiqu.video.bottom.last.w.h.rate.1.item'  # 二次兜底视频
-    }
+    # }
 
     # 头部视频对应运营强插的相关视频 redis 存储 key 前缀, 完整key格式：com.weiqu.video.relevant.videos.item.{videoId}
     RELEVANT_VIDEOS_WITH_OP_KEY_NAME = 'com.weiqu.video.relevant.videos.item.'
@@ -409,15 +416,15 @@ class BaseConfig(object):
     # 完整影视资源更新结果存放 redis key 前缀，完整格式：'com.weiqu.video.recall.whole.movies.item.{date}.{h}'
     RECALL_KEY_NAME_PREFIX_WHOLE_MOVIES = 'com.weiqu.video.recall.whole.movies.item.'
 
-    # 特殊mid更新结果存放 redis key ，完整格式：'com.weiqu.video.special.mid'
+    # 特殊mid更新结果存放 redis key ，完整格式：'special:mid'
-    KEY_NAME_SPECIAL_MID = 'com.weiqu.video.special.mid'
+    KEY_NAME_SPECIAL_MID = 'special:mid'
-    # 特殊mid对应指定视频列表更新结果存放 redis key 前缀，完整格式：'com.weiqu.video.special.videos.item.{date}'
+    # 特殊mid对应指定视频列表更新结果存放 redis key 前缀，完整格式：'special:videos:item:{date}'
-    KEY_NAME_PREFIX_SPECIAL_VIDEOS = 'com.weiqu.video.special.videos.item.'
+    KEY_NAME_PREFIX_SPECIAL_VIDEOS = 'special:videos:item:'
 
-    # 限流视频集合存放 redis key前缀，完整格式：'com.weiqu.video.limit.set.{date}'
+    # 限流视频集合存放 redis key前缀，完整格式：'limit:video:{date}'
-    KEY_NAME_PREFIX_LIMIT_VIDEO_SET = 'com.weiqu.video.limit.set.'
+    KEY_NAME_PREFIX_LIMIT_VIDEO_SET = 'limit:videos:'
-    # 限流视频分发数记录 redis key前缀，完整格式：'com.weiqu.video.limit.distribute.count.{videoId}'
+    # 限流视频分发数记录 redis key前缀，完整格式：'limit:video:distribute:count:{videoId}'
-    KEY_NAME_PREFIX_LIMIT_VIDEO_DISTRIBUTE_COUNT = 'com.weiqu.video.limit.distribute.count.'
+    KEY_NAME_PREFIX_LIMIT_VIDEO_DISTRIBUTE_COUNT = 'limit:video:distribute:count:'
 
     # 视频数据表类型 - 管理后台算法视频列表可视化
     VIDEO_DATA_LIST_MAPPING = {
@@ -470,7 +477,7 @@ class BaseConfig(object):
     }
 
     # 本山祝福视频redis存储key
-    BENSHAN_ZHUFU_KEY_NAME = 'com.weiqu.video.benshanzf'
+    BENSHAN_ZHUFU_KEY_NAME = 'benshanzf:videos'
     # 屏蔽视频配置 key:region_code, value:videos key list
     SHIELD_CONFIG = {
         '110000': [BENSHAN_ZHUFU_KEY_NAME, ],

manager_op.py

@@ -36,7 +36,7 @@ def get_video_list(ab_exp_code, search_time, data_list_type, region_code, page_n
         for item in key_prefix_list:
             data_list_code = item.get('dataListCode')
             key_prefix = item.get('keyPrefix')
-            key_name = f"{key_prefix}{region_code}.{app_type}.{data_key}.{rule_key}.{search_time}"
+            key_name = f"{key_prefix}{region_code}:{app_type}:{data_key}:{rule_key}:{search_time}"
             key_data = redis_helper.get_all_data_from_zset(key_name=key_name, desc=True, with_scores=True)
             if key_data is None:
                 continue
@@ -54,7 +54,7 @@ def get_video_list(ab_exp_code, search_time, data_list_type, region_code, page_n
             data.extend(videos)
     else:
         key_prefix = config_.VIDEO_DATA_LIST_MAPPING.get(data_list_type).get('keyPrefix')
-        key_name = f"{key_prefix}{region_code}.{app_type}.{data_key}.{rule_key}.{search_time}"
+        key_name = f"{key_prefix}{region_code}:{app_type}:{data_key}:{rule_key}:{search_time}"
         key_data = redis_helper.get_all_data_from_zset(key_name=key_name, desc=True, with_scores=True)
         if key_data is None:
             videos = []
@@ -116,7 +116,7 @@ def search_video(ab_exp_code, search_time, data_list_type, region_code, video_id
             data_list_code = item.get('dataListCode')
             key_prefix = item.get('keyPrefix')
             for code in code_list:
-                key_name = f"{key_prefix}{code}.{app_type}.{data_key}.{rule_key}.{search_time}"
+                key_name = f"{key_prefix}{code}:{app_type}:{data_key}:{rule_key}:{search_time}"
                 rank = redis_helper.get_rank_with_value(key_name=key_name, value=int(video_id), desc=True)
                 score = redis_helper.get_score_with_value(key_name=key_name, value=int(video_id))
                 if rank is None or score is None:
@@ -139,7 +139,7 @@ def search_video(ab_exp_code, search_time, data_list_type, region_code, video_id
         for item in key_prefix_list:
             data_list_code = item.get('dataListCode')
             key_prefix = item.get('keyPrefix')
-            key_name = f"{key_prefix}{region_code}.{app_type}.{data_key}.{rule_key}.{search_time}"
+            key_name = f"{key_prefix}{region_code}:{app_type}:{data_key}:{rule_key}:{search_time}"
             rank = redis_helper.get_rank_with_value(key_name=key_name, value=int(video_id), desc=True)
             score = redis_helper.get_score_with_value(key_name=key_name, value=int(video_id))
             if rank is None or score is None:
@@ -161,7 +161,7 @@ def search_video(ab_exp_code, search_time, data_list_type, region_code, video_id
         code_list = [code for _, code in config_.REGION_CODE.items()]
         key_prefix = config_.VIDEO_DATA_LIST_MAPPING.get(data_list_type).get('keyPrefix')
         for code in code_list:
-            key_name = f"{key_prefix}{code}.{app_type}.{data_key}.{rule_key}.{search_time}"
+            key_name = f"{key_prefix}{code}:{app_type}:{data_key}:{rule_key}:{search_time}"
             rank = redis_helper.get_rank_with_value(key_name=key_name, value=int(video_id), desc=True)
             score = redis_helper.get_score_with_value(key_name=key_name, value=int(video_id))
             if rank is None or score is None:
@@ -180,7 +180,7 @@ def search_video(ab_exp_code, search_time, data_list_type, region_code, video_id
 
     else:
         key_prefix = config_.VIDEO_DATA_LIST_MAPPING.get(data_list_type).get('keyPrefix')
-        key_name = f"{key_prefix}{region_code}.{app_type}.{data_key}.{rule_key}.{search_time}"
+        key_name = f"{key_prefix}{region_code}:{app_type}:{data_key}:{rule_key}:{search_time}"
         rank = redis_helper.get_rank_with_value(key_name=key_name, value=int(video_id), desc=True)
         score = redis_helper.get_score_with_value(key_name=key_name, value=int(video_id))
         if rank is not None and score is not None:

recommend.py

@@ -371,7 +371,7 @@ def update_redis_data(result, app_type, mid, last_rov_recall_key, top_K, expire_
         if mid and mid != 'null':
             # mid为空时，不做预曝光和定位数据更新
             # 预曝光数据同步刷新到Redis, 过期时间为0.5h
-            preview_key_name = config_.PREVIEW_KEY_PREFIX + '{}.{}'.format(app_type, mid)
+            preview_key_name = f"{config_.PREVIEW_KEY_PREFIX}{app_type}:{mid}"
             preview_video_ids = [int(item['videoId']) for item in result]
             if preview_video_ids:
                 # log_.error('key_name = {} \n values = {}'.format(preview_key_name, tuple(preview_video_ids)))
@@ -391,11 +391,11 @@ def update_redis_data(result, app_type, mid, last_rov_recall_key, top_K, expire_
                                                    expire_time=expire_time)
                 # log_.info('last video redis update success!')
 
-            # 将此次获取的 地域分组相对24h数据列表 中的视频id同步刷新到redis中，方便下次快速定位到召回位置
+            # 将此次获取的 地域分组小时级数据列表 中的视频id同步刷新到redis中，方便下次快速定位到召回位置
             rov_recall_h_video = [item['videoId'] for item in result[:top_K]
                                   if item['pushFrom'] == config_.PUSH_FROM['rov_recall_region_h']]
             if len(rov_recall_h_video) > 0:
-                last_video_key = f'{config_.LAST_VIDEO_FROM_REGION_H_PREFIX}{app_type}.{mid}'
+                last_video_key = f'{config_.LAST_VIDEO_FROM_REGION_H_PREFIX}{app_type}:{mid}'
                 redis_helper.set_data_to_redis(key_name=last_video_key, value=rov_recall_h_video[-1],
                                                expire_time=expire_time)
 
@@ -403,7 +403,7 @@ def update_redis_data(result, app_type, mid, last_rov_recall_key, top_K, expire_
             rov_recall_24h_dup1_video = [item['videoId'] for item in result[:top_K]
                                          if item['pushFrom'] == config_.PUSH_FROM['rov_recall_region_24h']]
             if len(rov_recall_24h_dup1_video) > 0:
-                last_video_key = f'{config_.LAST_VIDEO_FROM_REGION_DUP1_24H_PREFIX}{app_type}.{mid}'
+                last_video_key = f'{config_.LAST_VIDEO_FROM_REGION_DUP1_24H_PREFIX}{app_type}:{mid}'
                 redis_helper.set_data_to_redis(key_name=last_video_key, value=rov_recall_24h_dup1_video[-1],
                                                expire_time=expire_time)
 
@@ -411,7 +411,7 @@ def update_redis_data(result, app_type, mid, last_rov_recall_key, top_K, expire_
             rov_recall_24h_dup2_video = [item['videoId'] for item in result[:top_K]
                                          if item['pushFrom'] == config_.PUSH_FROM['rov_recall_24h']]
             if len(rov_recall_24h_dup2_video) > 0:
-                last_video_key = f'{config_.LAST_VIDEO_FROM_REGION_DUP2_24H_PREFIX}{app_type}.{mid}'
+                last_video_key = f'{config_.LAST_VIDEO_FROM_REGION_DUP2_24H_PREFIX}{app_type}:{mid}'
                 redis_helper.set_data_to_redis(key_name=last_video_key, value=rov_recall_24h_dup2_video[-1],
                                                expire_time=expire_time)
 
@@ -419,7 +419,7 @@ def update_redis_data(result, app_type, mid, last_rov_recall_key, top_K, expire_
             rov_recall_24h_dup3_video = [item['videoId'] for item in result[:top_K]
                                          if item['pushFrom'] == config_.PUSH_FROM['rov_recall_24h_dup']]
             if len(rov_recall_24h_dup3_video) > 0:
-                last_video_key = f'{config_.LAST_VIDEO_FROM_REGION_DUP3_24H_PREFIX}{app_type}.{mid}'
+                last_video_key = f'{config_.LAST_VIDEO_FROM_REGION_DUP3_24H_PREFIX}{app_type}:{mid}'
                 redis_helper.set_data_to_redis(key_name=last_video_key, value=rov_recall_24h_dup3_video[-1],
                                                expire_time=expire_time)
 
@@ -461,7 +461,7 @@ def update_local_distribute_count(videos):
     try:
         redis_helper = RedisHelper()
         for item in videos:
-            key_name = '{}{}.{}'.format(config_.LOCAL_DISTRIBUTE_COUNT_PREFIX, item['videoId'], item['flowPool'])
+            key_name = f"{config_.LOCAL_DISTRIBUTE_COUNT_PREFIX}{item['videoId']}:{item['flowPool']}"
             # 本地记录的分发数 - 1
             redis_helper.decr_key(key_name=key_name, amount=1, expire_time=5 * 60)
 
@@ -989,7 +989,7 @@ def special_mid_recommend(request_id, mid, uid, app_type, size,
     # 获取相关redis key
     special_key_name, redis_date = pool_recall.get_pool_redis_key(pool_type='special')
     # 用户上一次在rov召回池对应的位置
-    last_special_recall_key = f'{config_.LAST_VIDEO_FROM_ROV_POOL_PREFIX}{app_type}.{mid}.{redis_date}'
+    last_special_recall_key = f'{config_.LAST_VIDEO_FROM_SPECIAL_POOL_PREFIX}{app_type}:{mid}:{redis_date}'
     value = redis_helper.get_data_from_redis(last_special_recall_key)
     if value:
         idx = redis_helper.get_index_with_data(special_key_name, value)

user2new.py

@@ -24,17 +24,17 @@ def user2new(app_type, mid, uid):
 
     for app_type_item in app_type_list:
         # 清除对应的预曝光列表
-        preview_key = f"{config_.PREVIEW_KEY_PREFIX}{app_type_item}.{mid}"
+        preview_key = f"{config_.PREVIEW_KEY_PREFIX}{app_type_item}:{mid}"
         redis_helper.del_keys(key_name=preview_key)
 
         # 清除对应的小时级数据及数据记录
         h_key_prefix_list = [
-            config_.H_WITH_MID_RECALL_KEY_NAME_PREFIX,
+            # config_.H_WITH_MID_RECALL_KEY_NAME_PREFIX,
-            config_.H_WITH_MID_RECORD_KEY_NAME_PREFIX,
+            # config_.H_WITH_MID_RECORD_KEY_NAME_PREFIX,
-            config_.H_WITH_MID_RECALL_KEY_NAME_PREFIX_24H,
+            # config_.H_WITH_MID_RECALL_KEY_NAME_PREFIX_24H,
-            config_.H_WITH_MID_RECORD_KEY_NAME_PREFIX_24H,
+            # config_.H_WITH_MID_RECORD_KEY_NAME_PREFIX_24H,
-            config_.H_WITH_MID_RECALL_KEY_NAME_PREFIX_REGION_24H,
+            # config_.H_WITH_MID_RECALL_KEY_NAME_PREFIX_REGION_24H,
-            config_.H_WITH_MID_RECORD_KEY_NAME_PREFIX_REGION_24H,
+            # config_.H_WITH_MID_RECORD_KEY_NAME_PREFIX_REGION_24H,
             config_.LAST_VIDEO_FROM_REGION_DUP3_24H_PREFIX,
             config_.RECORD_KEY_NAME_PREFIX_LAST_VIDEO_REGION_DUP3_24H,
             config_.LAST_VIDEO_FROM_REGION_DUP2_24H_PREFIX,
@@ -45,18 +45,19 @@ def user2new(app_type, mid, uid):
             config_.RECORD_KEY_NAME_PREFIX_LAST_VIDEO_REGION_H,
         ]
         for h_key_prefix in h_key_prefix_list:
-            h_key_name = f"{h_key_prefix}{app_type_item}.{mid}"
+            h_key_name = f"{h_key_prefix}{app_type_item}:{mid}"
             redis_helper.del_keys(key_name=h_key_name)
 
         # 清除用户上一次列表中对应的位置记录数据
         last_idx_key_prefix_list = [
             config_.LAST_VIDEO_FROM_ROV_POOL_PREFIX,
-            config_.LAST_VIDEO_FROM_RULE_DAY_POOL_PREFIX,
+            # config_.LAST_VIDEO_FROM_RULE_DAY_POOL_PREFIX,
-            config_.LAST_VIDEO_FROM_ROV_POOL_PRE_PREFIX,
+            # config_.LAST_VIDEO_FROM_ROV_POOL_PRE_PREFIX,
-            config_.LAST_VIDEO_FROM_ROV_POOL_NOW_PREFIX,
+            # config_.LAST_VIDEO_FROM_ROV_POOL_NOW_PREFIX,
-            f"{config_.LAST_VIDEO_FROM_REGION_DUP_PREFIX}{1}.",
+            # f"{config_.LAST_VIDEO_FROM_REGION_DUP_PREFIX}{1}.",
-            f"{config_.LAST_VIDEO_FROM_REGION_DUP_PREFIX}{2}.",
+            # f"{config_.LAST_VIDEO_FROM_REGION_DUP_PREFIX}{2}.",
-            config_.LAST_VIDEO_FROM_WHOLE_MOVIES_PREFIX,
+            # config_.LAST_VIDEO_FROM_WHOLE_MOVIES_PREFIX,
+            config_.LAST_VIDEO_FROM_SPECIAL_POOL_PREFIX,
         ]
         # 天级
         now_date = date.today().strftime('%Y%m%d')
@@ -64,7 +65,7 @@ def user2new(app_type, mid, uid):
         date_list = [now_date, pre_date]
         for dt in date_list:
             for last_idx_key_prefix in last_idx_key_prefix_list:
-                h_key_name = f"{last_idx_key_prefix}{app_type_item}.{mid}.{dt}"
+                h_key_name = f"{last_idx_key_prefix}{app_type_item}:{mid}:{dt}"
                 redis_helper.del_keys(key_name=h_key_name)
         # 小时级
         h = datetime.now().hour
@@ -75,5 +76,5 @@ def user2new(app_type, mid, uid):
             h_list.append(h-1)
         for redis_h in h_list:
             for last_idx_key_prefix in last_idx_key_prefix_list:
-                h_key_name = f"{last_idx_key_prefix}{app_type_item}.{mid}.{redis_h}"
+                h_key_name = f"{last_idx_key_prefix}{app_type_item}:{mid}:{redis_h}"
                 redis_helper.del_keys(key_name=h_key_name)

utils.py

@@ -91,7 +91,7 @@ def get_videos_local_distribute_count(video_id, flow_pool):
     # if datetime.now().minute >= 30:
     #     redis_h += 0.5
     # key_name = config_.LOCAL_DISTRIBUTE_COUNT_PREFIX + str(redis_h)
-    key_name = '{}{}.{}'.format(config_.LOCAL_DISTRIBUTE_COUNT_PREFIX, video_id, flow_pool)
+    key_name = f'{config_.LOCAL_DISTRIBUTE_COUNT_PREFIX}{video_id}:{flow_pool}'
     redis_helper = RedisHelper()
     # video = '{}-{}'.format(video_id, flow_pool)
     # current_count = redis_helper.get_score_with_value(key_name=key_name, value=video)
@@ -327,7 +327,7 @@ class FilterVideos(object):
         # 根据Redis缓存中的数据过滤
         redis_helper = RedisHelper()
         # key拼接
-        key_name = config_.PREVIEW_KEY_PREFIX + '{}.{}'.format(self.app_type, self.mid)
+        key_name = f"{config_.PREVIEW_KEY_PREFIX}{self.app_type}:{self.mid}"
         pe_videos_list = redis_helper.get_data_from_set(key_name)
         # log_.info('****app_type = {}, mid = {}, uid = {}, pe_videos_list = {}'.format(
         #     self.app_type, self.mid, self.uid, pe_videos_list))

video_recall.py

@@ -568,7 +568,7 @@ class PoolRecall(object):
                 else:
                     value = '{}-{}'.format(video_id, flow_pool)
                     for item in config_.APP_TYPE:
-                        flow_pool_key = config_.FLOW_POOL_KEY_NAME_PREFIX + str(config_.APP_TYPE.get(item))
+                        flow_pool_key = f"{config_.FLOWPOOL_KEY_NAME_PREFIX}{config_.APP_TYPE.get(item)}"
                         self.redis_helper.remove_value_from_zset(key_name=flow_pool_key, value=value)
         # 本次视频都有本地记录
         if len(videos) == 0:
@@ -608,14 +608,14 @@ class PoolRecall(object):
                 # viewCount > 0
                 check_result.append(item)
                 # 将分发数更新到本地记录
-                key_name = '{}{}.{}'.format(config_.LOCAL_DISTRIBUTE_COUNT_PREFIX, item[0], item[1])
+                key_name = f"{config_.LOCAL_DISTRIBUTE_COUNT_PREFIX}{item[0]}:{item[1]}"
                 self.redis_helper.setnx_key(key_name=key_name, value=remain_count, expire_time=5 * 60)
             else:
                 # viewCount <= 0
                 # 从流量召回池移除
                 value = '{}-{}'.format(item[0], item[1])
                 for item in config_.APP_TYPE:
-                    flow_pool_key = config_.FLOW_POOL_KEY_NAME_PREFIX + str(config_.APP_TYPE.get(item))
+                    flow_pool_key = f"{config_.FLOWPOOL_KEY_NAME_PREFIX}{config_.APP_TYPE.get(item)}"
                     self.redis_helper.remove_value_from_zset(key_name=flow_pool_key, value=value)
         return check_result, error_flag
 
@@ -661,19 +661,19 @@ class PoolRecall(object):
 
         elif pool_type == 'flow':
             if flow_pool_id == config_.QUICK_FLOW_POOL_ID:
-                return f"{config_.QUICK_FLOWPOOL_KEY_NAME_PREFIX}{self.app_type}.{config_.QUICK_FLOW_POOL_ID}"
+                return f"{config_.QUICK_FLOWPOOL_KEY_NAME_PREFIX}{self.app_type}:{config_.QUICK_FLOW_POOL_ID}"
             else:
-                return f"{config_.FLOW_POOL_KEY_NAME_PREFIX}{self.app_type}"
+                return f"{config_.FLOWPOOL_KEY_NAME_PREFIX}{self.app_type}"
 
         elif pool_type == 'special':
             key_name_prefix = config_.KEY_NAME_PREFIX_SPECIAL_VIDEOS
             # 判断列表是否更新，未更新则使用前一天的列表
-            key_name = key_name_prefix + time.strftime('%Y%m%d')
+            key_name = f"{key_name_prefix}{time.strftime('%Y%m%d')}"
             if self.redis_helper.key_exists(key_name):
                 redis_date = date.today().strftime('%Y%m%d')
             else:
                 redis_date = (date.today() - timedelta(days=1)).strftime('%Y%m%d')
-                key_name = key_name_prefix + redis_date
+                key_name = f"{key_name_prefix}{redis_date}"
                 # 判断当前时间是否晚于更新时间，发送消息到飞书
                 # now_h = datetime.now().hour
                 # feishu_text = '{} —— 今日special mid 数据未按时更新，请及时查看解决。'.format(config_.ENV_TEXT)
@@ -716,7 +716,7 @@ class PoolRecall(object):
             last_key_prefix = config_.LAST_VIDEO_FROM_WHOLE_MOVIES_PREFIX
         else:
             last_key_prefix = config_.LAST_VIDEO_FROM_ROV_POOL_PREFIX
-        last_rov_recall_key = f'{last_key_prefix}{self.app_type}.{self.mid}.{redis_date}'
+        last_rov_recall_key = f'{last_key_prefix}{self.app_type}:{self.mid}:{redis_date}'
         value = self.redis_helper.get_data_from_redis(last_rov_recall_key)
         if value:
             idx = self.redis_helper.get_index_with_data(rov_pool_key, value)
@@ -893,8 +893,8 @@ class PoolRecall(object):
                 config_.AB_CODE['top_video_relevant_appType_19']
             ]:
                 # 判断热度列表是否更新，未更新则使用前一小时的热度列表
-                key_name_prefix = f"{config_.RECALL_KEY_NAME_PREFIX_APP_TYPE}{self.app_type}."
+                key_name_prefix = f"{config_.RECALL_KEY_NAME_PREFIX_APP_TYPE}{self.app_type}:"
-                key_name = f"{key_name_prefix}{now_date}.{h}"
+                key_name = f"{key_name_prefix}{now_date}:{h}"
                 if self.redis_helper.key_exists(key_name):
                     return key_name, h
                 else:
@@ -904,7 +904,7 @@ class PoolRecall(object):
                     else:
                         redis_h = h - 1
                         redis_date = now_date
-                    key_name = f"{key_name_prefix}{redis_date}.{redis_h}"
+                    key_name = f"{key_name_prefix}{redis_date}:{redis_h}"
                     # 判断当前时间是否晚于数据正常更新时间，发送消息到飞书
                     # now_m = datetime.now().minute
                     # feishu_text = '{} —— appType = {}, h = {} 数据未按时更新，请及时查看解决。'.format(
@@ -946,12 +946,12 @@ class PoolRecall(object):
                     if self.ab_code == config_.AB_CODE['region_rank_by_h'].get('region_rule_rank2'):
                         key_prefix = f"{config_.RECALL_KEY_NAME_PREFIX_DUP_REGION_24H}{province_code}."
                     else:
-                        key_prefix = f"{config_.RECALL_KEY_NAME_PREFIX_DUP_REGION_H}{province_code}."
+                        key_prefix = f"{config_.RECALL_KEY_NAME_PREFIX_DUP_REGION_H}{province_code}:"
                 elif self.ab_code in [code for _, code in config_.AB_CODE['rank_by_24h'].items()]:
                     key_prefix = config_.RECALL_KEY_NAME_PREFIX_DUP_24H
                 else:
                     key_prefix = config_.RECALL_KEY_NAME_PREFIX_DUP_H
-                key_name = f"{key_prefix}{self.app_type}.{self.data_key}.{self.rule_key}.{now_date}.{h}"
+                key_name = f"{key_prefix}{self.app_type}:{self.data_key}:{self.rule_key}:{now_date}:{h}"
                 if self.redis_helper.key_exists(key_name):
                     return key_name, h
                 else:
@@ -961,7 +961,7 @@ class PoolRecall(object):
                     else:
                         redis_h = h - 1
                         redis_date = now_date
-                    key_name = f"{key_prefix}{self.app_type}.{self.data_key}.{self.rule_key}.{redis_date}.{redis_h}"
+                    key_name = f"{key_prefix}{self.app_type}:{self.data_key}:{self.rule_key}:{redis_date}:{redis_h}"
                     # 判断当前时间是否晚于数据正常更新时间，发送消息到飞书
                     # now_m = datetime.now().minute
                     # feishu_text = '{} —— appType = {}, h = {}, key = {}, province_code = {} 数据未按时更新，请及时查看解决。'.format(
@@ -1184,13 +1184,13 @@ class PoolRecall(object):
         if province_code == '':
             province_code = '-1'
 
-        if self.ab_code == config_.AB_CODE['region_rank_by_h'].get('region_rule_rank2'):
+        # if self.ab_code == config_.AB_CODE['region_rank_by_h'].get('region_rule_rank2'):
-            if province_code == '-1':
+        #     if province_code == '-1':
-                t = [gevent.spawn(self.region_dup_recall, province_code, 2, size, expire_time)]
+        #         t = [gevent.spawn(self.region_dup_recall, province_code, 2, size, expire_time)]
-            else:
+        #     else:
-                t = [gevent.spawn(self.rov_pool_recall_with_region_by_h, province_code, size, 'region_24h'),
+        #         t = [gevent.spawn(self.rov_pool_recall_with_region_by_h, province_code, size, 'region_24h'),
-                     gevent.spawn(self.region_dup_recall, province_code, 2, size, expire_time)]
+        #              gevent.spawn(self.region_dup_recall, province_code, 2, size, expire_time)]
-        elif self.ab_code == config_.AB_CODE['region_rank_by_h'].get('region_rule_rank5_appType_0_data1'):
+        if self.ab_code == config_.AB_CODE['region_rank_by_h'].get('region_rule_rank5_appType_0_data1'):
             if province_code == '-1':
                 t = [
                     # gevent.spawn(self.rov_pool_recall_with_region_by_h, province_code, size, 'day_24h'),
@@ -1613,7 +1613,7 @@ class PoolRecall(object):
         now_date = datetime.today()
         h = datetime.now().hour
         now_dt = datetime.strftime(now_date, '%Y%m%d')
-        now_pool_recall_key = f"{pool_key_prefix}{province_code}.{self.app_type}.{self.data_key}.{self.rule_key}.{now_dt}.{h}"
+        now_pool_recall_key = f"{pool_key_prefix}{province_code}:{self.app_type}:{self.data_key}:{self.rule_key}:{now_dt}:{h}"
         if self.redis_helper.key_exists(key_name=now_pool_recall_key):
             value = {'date': now_dt, 'h': h}
             self.redis_helper.set_data_to_redis(key_name=record_key, value=str(value), expire_time=2 * 3600)
@@ -1624,7 +1624,7 @@ class PoolRecall(object):
             else:
                 redis_dt = now_dt
                 redis_h = h - 1
-            now_pool_recall_key = f"{pool_key_prefix}{province_code}.{self.app_type}.{self.data_key}.{self.rule_key}.{redis_dt}.{redis_h}"
+            now_pool_recall_key = f"{pool_key_prefix}{province_code}:{self.app_type}:{self.data_key}:{self.rule_key}:{redis_dt}:{redis_h}"
             value = {'date': redis_dt, 'h': redis_h}
             self.redis_helper.set_data_to_redis(key_name=record_key, value=str(value), expire_time=2 * 3600)
         return now_pool_recall_key
@@ -1651,8 +1651,8 @@ class PoolRecall(object):
         # 判断mid对应上一次视频位置 时间记录
         # record_key = f"{config_.RECORD_KEY_NAME_PREFIX_LAST_VIDEO_REGION_DUP3_24H}{self.app_type}.{self.mid}"
         # pool_key_prefix = config_.RECALL_KEY_NAME_PREFIX_DUP3_REGION_24H_H
-        record_key = f"{record_key_prefix}{self.app_type}.{self.mid}"
+        record_key = f"{record_key_prefix}{self.app_type}:{self.mid}"
-        last_video_key = f'{last_video_key_prefix}{self.app_type}.{self.mid}'
+        last_video_key = f'{last_video_key_prefix}{self.app_type}:{self.mid}'
 
         if not self.redis_helper.key_exists(key_name=record_key):
             # ###### 记录key不存在
@@ -1671,11 +1671,11 @@ class PoolRecall(object):
             now_dt = datetime.strftime(now_date, '%Y%m%d')
             if record_dt == now_dt and int(record_h) == h:
                 # 已获取当前小时数据
-                pool_recall_key = f"{pool_key_prefix}{province_code}.{self.app_type}.{self.data_key}.{self.rule_key}.{now_dt}.{h}"
+                pool_recall_key = f"{pool_key_prefix}{province_code}:{self.app_type}:{self.data_key}:{self.rule_key}:{now_dt}:{h}"
                 idx = self.get_video_idx(pool_recall_key=pool_recall_key, last_video_key=last_video_key)
             elif (record_dt == now_dt and h-int(record_h) == 1) or (h == 0 and int(record_h) == 23):
                 # 记录的h - 当前h = 1，判断当前h数据是否已更新
-                now_pool_recall_key = f"{pool_key_prefix}{province_code}.{self.app_type}.{self.data_key}.{self.rule_key}.{now_dt}.{h}"
+                now_pool_recall_key = f"{pool_key_prefix}{province_code}:{self.app_type}:{self.data_key}:{self.rule_key}:{now_dt}:{h}"
                 if self.redis_helper.key_exists(key_name=now_pool_recall_key):
                     new_record = {'date': now_dt, 'h': h}
                     self.redis_helper.set_data_to_redis(key_name=record_key, value=str(new_record), expire_time=2*3600)
@@ -1683,7 +1683,7 @@ class PoolRecall(object):
                     self.redis_helper.del_keys(key_name=last_video_key)
                     pool_recall_key = now_pool_recall_key
                 else:
-                    pool_recall_key = f"{pool_key_prefix}{province_code}.{self.app_type}.{self.data_key}.{self.rule_key}.{record_dt}.{record_h}"
+                    pool_recall_key = f"{pool_key_prefix}{province_code}:{self.app_type}:{self.data_key}:{self.rule_key}:{record_dt}:{record_h}"
                     idx = self.get_video_idx(pool_recall_key=pool_recall_key, last_video_key=last_video_key)
             else:
                 idx = 0
@@ -1783,8 +1783,7 @@ class PoolRecall(object):
                 # 将此次获取的末位视频id同步刷新到Redis中，方便下次快速定位到召回位置，过期时间为1天
                 if self.mid:
                     # mid为空时，不做记录
-                    # last_video_key = f'{config_.LAST_VIDEO_FROM_REGION_DUP3_24H_PREFIX}{self.app_type}.{self.mid}'
+                    last_video_key = f'{last_video_key_prefix}{self.app_type}:{self.mid}'
-                    last_video_key = f'{last_video_key_prefix}{self.app_type}.{self.mid}'
                     self.redis_helper.set_data_to_redis(key_name=last_video_key, value=data[-1][0],
                                                         expire_time=expire_time)
             idx += get_size