Update app.py

app.py

@@ -1278,6 +1278,22 @@ def generate_schedule_check_logs(schedule_list, date_str, today_analysis_df=None
 
     df_check = df_original.sort_values(by='startTime').reset_index(drop=True)
     
+    # 提前清洗电影名称
+    df_check['clean_filmName'] = df_check['filmName'].apply(clean_movie_title)
+    
+    # 获取次日大盘预售票房数据
+    next_day_bo_data = fetch_realtime_box_office(date_str)
+    movie_box_office = {}
+    bo_sorted_movies = []
+    if next_day_bo_data and 'movieDatalist' in next_day_bo_data:
+        bo_df = process_box_office_data(next_day_bo_data['movieDatalist'], include_fee=True)
+        if not bo_df.empty:
+            bo_df['clean_filmName'] = bo_df['影片名称'].apply(clean_movie_title)
+            for _, row in bo_df.iterrows():
+                if row['clean_filmName'] not in movie_box_office:
+                    movie_box_office[row['clean_filmName']] = row['今日票房']
+                    bo_sorted_movies.append(row['clean_filmName'])
+    
     # 提取绝对核心片名（去除所有括号及制式/语言后缀），用于同影片判断
     import re
     df_check['coreFilmName'] = df_check['filmName'].apply(lambda x: re.sub(r'[（\(].*?[）\)]', '', str(x)).strip())
@@ -1497,17 +1513,22 @@ def generate_schedule_check_logs(schedule_list, date_str, today_analysis_df=None
             [(dt_time(14, 0), dt_time(17, 0)), (dt_time(19, 0), dt_time(21, 30))]
         ][weekday]
 
-        film_counts = df_check['filmName'].value_counts()
+        film_counts = df_check['clean_filmName'].value_counts()
         if not film_counts.empty:
-            max_count = film_counts.iloc[0]
-            # 定义热门影片：排片量接近第一名（95%以上）的影片
-            hot_films = film_counts[film_counts >= max_count * 0.95].index.tolist()
+            if bo_sorted_movies:
+                # 预售票房排行
+                max_bo = movie_box_office.get(bo_sorted_movies[0], 0)
+                hot_films = [m for m, bo in movie_box_office.items() if bo >= max_bo * 0.95]
+            else:
+                max_count = film_counts.iloc[0]
+                # 定义热门影片：排片量接近第一名（95%以上）的影片
+                hot_films = film_counts[film_counts >= max_count * 0.95].index.tolist()
 
             golden_hour_schedules = df_check[
                 df_check['startTime'].apply(lambda dt: any(start <= dt.time() < end for start, end in golden_hours_r9))]
 
             for film in hot_films:
-                hot_film_total_in_golden = len(golden_hour_schedules[golden_hour_schedules['filmName'] == film])
+                hot_film_total_in_golden = len(golden_hour_schedules[golden_hour_schedules['clean_filmName'] == film])
                 golden_total = len(golden_hour_schedules)
                 if golden_total > 0:
                     ratio = hot_film_total_in_golden / golden_total
@@ -1527,12 +1548,6 @@ def generate_schedule_check_logs(schedule_list, date_str, today_analysis_df=None
     final_log_parts.append("\n规则十：次日排片效率匹配度检查")
 
     if today_analysis_df is not None and not today_analysis_df.empty:
-        # 清洗明天的电影名称以匹配今天的电影名称
-        def clean_tomorrow_movie_name(name):
-            return clean_movie_title(name)
-
-        df_check['clean_filmName'] = df_check['filmName'].apply(clean_tomorrow_movie_name)
-        
         # 计算明天每部电影的总场次和黄金场次
         tomorrow_stats = {}
         for film in df_check['clean_filmName'].unique():
@@ -1548,7 +1563,7 @@ def generate_schedule_check_logs(schedule_list, date_str, today_analysis_df=None
         if today_prime_df is not None and not today_prime_df.empty:
             today_prime_map = today_prime_df.set_index('影片')['场次效率'].to_dict()
         
-        today_analysis_df['clean_filmName'] = today_analysis_df['影片'].apply(clean_tomorrow_movie_name)
+        today_analysis_df['clean_filmName'] = today_analysis_df['影片'].apply(clean_movie_title)
 
         for _, row in today_analysis_df.iterrows():
             film = row['clean_filmName']
@@ -1663,8 +1678,13 @@ def generate_schedule_check_logs(schedule_list, date_str, today_analysis_df=None
     final_log_parts.append("\n规则十一：22:00 后热门影片排片检查")
 
     if today_analysis_df is not None and not today_analysis_df.empty:
-        # 1. 找出排片最多的前3部影片
-        top_movies = df_check['clean_filmName'].value_counts().head(3).index.tolist()
+        # 1. 找出热门前3部影片（优先票房，其次排片量）
+        if bo_sorted_movies:
+            top_movies = bo_sorted_movies[:3]
+            top_movies_type = "票房排行前三"
+        else:
+            top_movies = df_check['clean_filmName'].value_counts().head(3).index.tolist()
+            top_movies_type = "排片量前三"
         
         if not top_movies:
             logs_r11.append("次日无排片数据，无法检查。")
@@ -1688,7 +1708,7 @@ def generate_schedule_check_logs(schedule_list, date_str, today_analysis_df=None
             
             if not has_top_movie_at_night:
                 top_movies_str = "、".join([f"《{m}》" for m in top_movies])
-                logs_r11.append(f"排片量前三的影片 {top_movies_str} 在 22:00 后均无场次，建议增加热门影片晚场。")
+                logs_r11.append(f"{top_movies_type}的影片 {top_movies_str} 在 22:00 后均无场次，建议增加热门影片晚场。")
 
     if logs_r11:
         for i, log in enumerate(logs_r11, 1):
@@ -1696,6 +1716,30 @@ def generate_schedule_check_logs(schedule_list, date_str, today_analysis_df=None
     else:
         final_log_parts.append("（无）")
 
+    # --- Rule 12: 次日票房排行前五的影片必须有一场黄金场 ---
+    logs_r12 = []
+    final_log_parts.append("\n规则十二：次日票房前五的影片必须有一场黄金场")
+    if bo_sorted_movies:
+        top_5_movies = bo_sorted_movies[:5]
+        for movie in top_5_movies:
+            movie_df = df_check[df_check['clean_filmName'] == movie]
+            if not movie_df.empty:
+                golden_sessions = movie_df[movie_df['startTime'].apply(
+                    lambda dt: dt_time(14, 0) <= dt.time() <= dt_time(21, 0)
+                )]
+                if golden_sessions.empty:
+                    logs_r12.append(f"《{movie}》为次日票房排行前五的影片，但没有安排黄金场（14:00-21:00）。")
+            else:
+                logs_r12.append(f"《{movie}》为次日票房排行前五的影片，但目前未排片。")
+    else:
+        logs_r12.append("未获取到次日票房数据，无法检查规则十二。")
+
+    if logs_r12:
+        for i, log in enumerate(logs_r12, 1):
+            final_log_parts.append(f"{i}. {log}")
+    else:
+        final_log_parts.append("（无）")
+
     return "\n".join(final_log_parts)