Update app.py

app.py

@@ -6,72 +6,79 @@ import io
 import base64
 import os
 from datetime import datetime, timedelta
-import numpy as np
-from matplotlib.backends.backend_agg import FigureCanvasAgg
+from matplotlib.patches import Rectangle
 from pypinyin import lazy_pinyin, Style
 from matplotlib.backends.backend_pdf import PdfPages
 
+# --- 字体设置 ---
 def get_font(size=14):
-    """Loads the specified font, with a fallback."""
-    font_path = "simHei.ttc"
+    """根据操作系统环境查找并返回中文字体属性"""
+    font_path = "simHei.ttc" # 优先使用 simHei.ttc
     if not os.path.exists(font_path):
-        font_path = "SimHei.ttf"  # Fallback font
+        font_path = "SimHei.ttf" # SimHei.ttf 作为备选
+    # 如果两者都不存在，可以添加更多备选字体路径
     if not os.path.exists(font_path):
-        st.warning("Font file (simHei.ttc or SimHei.ttf) not found. Display may be incorrect.")
-        return font_manager.FontProperties(size=size)
+        # for Windows
+        font_path = "C:/Windows/Fonts/simhei.ttf"
+    if not os.path.exists(font_path):
+        # for MacOS
+         font_path = "/System/Library/Fonts/STHeiti Medium.ttc"
+    # 如果仍然找不到，matplotlib会回退到默认字体
     return font_manager.FontProperties(fname=font_path, size=size)
 
+# --- 拼音处理 ---
 def get_pinyin_abbr(text):
-    """Gets the first letter of the Pinyin for the first two Chinese characters of a text."""
-    if not isinstance(text, str):
+    """获取文本前两个汉字的拼音首字母"""
+    if not text or not isinstance(text, str):
         return ""
-    # Extract the first two Chinese characters
-    chars = [c for c in text if '\u4e00' <= c <= '\u9fff'][:2]
-    if not chars:
+    # 提取中文字符
+    chars = [c for c in text if '\u4e00' <= c <= '\u9fff']
+    # 取前两个汉字
+    chars_to_process = chars[:2]
+    if not chars_to_process:
         return ""
-    pinyin_list = lazy_pinyin(chars, style=Style.FIRST_LETTER)
+    # 获取拼音首字母并转为大写
+    pinyin_list = lazy_pinyin(chars_to_process, style=Style.FIRST_LETTER)
     return ''.join(pinyin_list).upper()
 
+# --- 数据处理 ---
 def process_schedule(file):
-    """
-    Processes the uploaded Excel file to extract and clean the movie schedule.
-    This version also prepares all data fields needed for the new layout.
-    """
+    """读取并处理 Excel 文件，返回格式化的 DataFrame 和日期"""
     try:
-        # Try to read the date from the specified cell
+        # 尝试读取日期
         date_df = pd.read_excel(file, header=None, skiprows=7, nrows=1, usecols=[3])
         date_str = pd.to_datetime(date_df.iloc[0, 0]).strftime('%Y-%m-%d')
         base_date = pd.to_datetime(date_str).date()
     except Exception:
-        # Fallback to today's date if reading fails
+        # 读取失败则使用当天日期
         date_str = datetime.today().strftime('%Y-%m-%d')
         base_date = datetime.today().date()
-    
+
     try:
+        # 读取排片数据
         df = pd.read_excel(file, header=9, usecols=[1, 2, 4, 5])
         df.columns = ['Hall', 'StartTime', 'EndTime', 'Movie']
         
-        # Data Cleaning
+        # 数据清洗
         df['Hall'] = df['Hall'].ffill()
         df.dropna(subset=['StartTime', 'EndTime', 'Movie'], inplace=True)
         df['Hall'] = df['Hall'].astype(str).str.extract(r'(\d+号)')
-        df.dropna(subset=['Hall'], inplace=True) # Ensure rows without a hall number are dropped
+        df.dropna(subset=['Hall'], inplace=True)
 
-        # Convert times to datetime objects
+        # 时间转换
         df['StartTime_dt'] = pd.to_datetime(df['StartTime'], format='%H:%M', errors='coerce').apply(
             lambda t: t.replace(year=base_date.year, month=base_date.month, day=base_date.day) if pd.notnull(t) else t
         )
         df['EndTime_dt'] = pd.to_datetime(df['EndTime'], format='%H:%M', errors='coerce').apply(
             lambda t: t.replace(year=base_date.year, month=base_date.month, day=base_date.day) if pd.notnull(t) else t
         )
-        
         df.dropna(subset=['StartTime_dt', 'EndTime_dt'], inplace=True)
         
-        # Handle screenings that cross midnight
+        # 处理跨天结束时间
         df.loc[df['EndTime_dt'] < df['StartTime_dt'], 'EndTime_dt'] += timedelta(days=1)
         df = df.sort_values(['Hall', 'StartTime_dt'])
         
-        # Merge consecutive screenings of the same movie
+        # 合并同一影厅的连续相同影片
         merged_rows = []
         for _, group in df.groupby('Hall'):
             group = group.sort_values('StartTime_dt')
@@ -81,7 +88,7 @@ def process_schedule(file):
                     current = row.copy()
                 else:
                     if row['Movie'] == current['Movie']:
-                        current['EndTime_dt'] = row['EndTime_dt'] # Extend the end time
+                        current['EndTime_dt'] = row['EndTime_dt']
                     else:
                         merged_rows.append(current)
                         current = row.copy()
@@ -89,194 +96,219 @@ def process_schedule(file):
                 merged_rows.append(current)
         
         if not merged_rows:
-             return None, date_str
-
-        merged_df = pd.DataFrame(merged_rows).reset_index(drop=True)
+            return None, date_str
+            
+        merged_df = pd.DataFrame(merged_rows)
         
-        # Adjust times as per original logic
+        # 统一调整时间
         merged_df['StartTime_dt'] -= timedelta(minutes=10)
         merged_df['EndTime_dt'] -= timedelta(minutes=5)
         
-        # --- New Data Preparation for Layout ---
-        # 1. Create Index (序号)
-        merged_df['Index'] = merged_df.groupby('Hall').cumcount() + 1
-        # 2. Create Pinyin Abbreviation (拼音缩写)
+        # 格式化最终输出的列
+        merged_df['Time'] = merged_df['StartTime_dt'].dt.strftime('%H:%M') + ' - ' + merged_df['EndTime_dt'].dt.strftime('%H:%M')
         merged_df['Pinyin'] = merged_df['Movie'].apply(get_pinyin_abbr)
-        # 3. Create Time String (时间)
-        merged_df['TimeStr'] = merged_df['StartTime_dt'].dt.strftime('%H:%M') + ' - ' + merged_df['EndTime_dt'].dt.strftime('%H:%M')
-        # 4. Clean Hall Number for display
         merged_df['Hall'] = merged_df['Hall'].str.replace('号', '')
-
-        # Select and reorder columns as per requirement
-        final_df = merged_df[['Hall', 'Index', 'Movie', 'Pinyin', 'TimeStr']]
         
-        return final_df, date_str
+        return merged_df[['Hall', 'Movie', 'Pinyin', 'Time']], date_str
 
     except Exception as e:
-        st.error(f"An error occurred during file processing: {e}")
+        st.error(f"处理 Excel 数据时发生错误: {e}")
         return None, date_str
 
 
+# --- 打印布局生成 ---
 def create_print_layout(data, date_str):
-    """
-    Creates the print layout on an A4 page based on a dynamic grid system.
-    """
+    """根据处理好的数据，生成用于打印的 PNG 和 PDF 布局"""
     if data is None or data.empty:
         return None
 
-    # --- 1. Layout Constants ---
-    A4_WIDTH_IN, A4_HEIGHT_IN = 8.27, 11.69
-    MARGIN_IN = 0.4
-    USABLE_WIDTH_IN = A4_WIDTH_IN - (2 * MARGIN_IN)
-    USABLE_HEIGHT_IN = A4_HEIGHT_IN - (2 * MARGIN_IN)
-
-    # --- 2. Row and Font Calculation ---
-    num_content_rows = len(data)
-    total_grid_rows = num_content_rows + 2  # Add 2 for top/bottom padding rows
-    row_height_in = USABLE_HEIGHT_IN / total_grid_rows
-    # Calculate font size in points (1 inch = 72 points) to be 90% of row height
-    font_size_pt = (row_height_in * 72) * 0.9
-    content_font = get_font(font_size_pt)
-    date_font = get_font(12)
-
-    # --- 3. Column Width Calculation ---
-    # Create a temporary figure to calculate text widths accurately
-    temp_fig = plt.figure(figsize=(A4_WIDTH_IN, A4_HEIGHT_IN))
-    canvas = FigureCanvasAgg(temp_fig)
+    A4_SIZE_INCHES = (8.27, 11.69)
+    DPI = 300
+    
+    # 准备一个临时的 figure 用于计算文本渲染尺寸
+    temp_fig = plt.figure(figsize=A4_SIZE_INCHES, dpi=DPI)
+    renderer = temp_fig.canvas.get_renderer()
+
+    # 1. 计算行高
+    num_movies = len(data)
+    num_halls = len(data['Hall'].unique())
+    # 总行数 = 电影条目数 + 厅间分隔数 + 上下留白(2)
+    # total_layout_rows = num_movies + (num_halls - 1) + 2
+    total_layout_rows = num_movies + 2 # 简化为条目数+2，使行高更宽松
+    row_height_inch = A4_SIZE_INCHES[1] / total_layout_rows
     
-    cols_to_measure = ['Hall', 'Index', 'Movie', 'Pinyin', 'TimeStr']
-    col_widths_in = []
-
-    for col in cols_to_measure:
-        # Find the longest string in the column for measurement
-        longest_item = max(data[col].astype(str).tolist(), key=len, default="")
-        # Create a temporary text object to measure its width
-        t = plt.text(0, 0, longest_item, fontproperties=content_font)
-        # Get the bounding box of the text in display units and convert to inches
-        bbox = t.get_window_extent(renderer=canvas.get_renderer())
-        width_in = bbox.width / temp_fig.dpi
-        col_widths_in.append(width_in * 1.1) # Add 10% padding
+    # 2. 计算基准字体大小 (点)
+    # 1 point = 1/72 inch.
+    # 字体高度为行高的 90%
+    font_size_pt = row_height_inch * 0.9 * 72 
+    base_font = get_font(font_size_pt)
+
+    # 3. 计算各列宽度 (除电影名外)
+    def get_text_width_inch(text, font):
+        t = plt.text(0, 0, text, fontproperties=font)
+        bbox = t.get_window_extent(renderer=renderer)
+        width_pixels = bbox.width
         t.remove()
+        return width_pixels / DPI
 
-    plt.close(temp_fig) # Close the temporary figure
+    # 找到每列最长的内容
+    data['Index'] = data.groupby('Hall').cumcount() + 1
+    max_hall_str = data['Hall'].max() + "#" # e.g. "10#"
+    max_index_str = str(data['Index'].max()) + "." # e.g. "5."
+    max_pinyin_str = data['Pinyin'].apply(len).max() * "A" # e.g. "PY" -> "AA"
+    max_time_str = data['Time'].apply(len).idxmax()
+    max_time_str = data.loc[max_time_str, 'Time']
 
-    # Scale column widths to fit the usable page width
-    total_calculated_width = sum(col_widths_in)
-    scale_factor = USABLE_WIDTH_IN / total_calculated_width if total_calculated_width > 0 else 1
-    final_col_widths_in = [w * scale_factor for w in col_widths_in]
+    col_widths = {}
+    col_widths['Hall'] = get_text_width_inch(max_hall_str, base_font) * 1.1
+    col_widths['Index'] = get_text_width_inch(max_index_str, base_font) * 1.1
+    col_widths['Pinyin'] = get_text_width_inch(max_pinyin_str, base_font) * 1.1
+    col_widths['Time'] = get_text_width_inch(max_time_str, base_font) * 1.1
+    
+    # 电影名列的宽度为剩余宽度
+    non_movie_width = sum(col_widths.values())
+    col_widths['Movie'] = A4_SIZE_INCHES[0] - non_movie_width
 
-    # --- 4. Figure and PDF/PNG Generation ---
-    def process_figure(fig, ax):
-        # Calculate grid coordinates in Axes units (0 to 1)
-        col_widths_ax = [w / USABLE_WIDTH_IN for w in final_col_widths_in]
-        row_height_ax = 1.0 / total_grid_rows
-        
-        x_coords_ax = [0] + np.cumsum(col_widths_ax).tolist()
-        y_coords_ax = [1 - i * row_height_ax for i in range(total_grid_rows + 1)]
-
-        # Add date string at the top-left of the usable area
-        ax.text(0, 1, date_str, transform=ax.transAxes, fontproperties=date_font,
-                ha='left', va='bottom', color='#A9A9A9')
-
-        # --- Draw Grid and Content ---
-        for i, row in data.iterrows():
-            grid_row_index = i + 1  # Offset by 1 for the top padding row
-            y_bottom = y_coords_ax[grid_row_index + 1]
-            y_center = y_bottom + row_height_ax / 2
-
-            # Draw bottom dotted line for the current row's cells
-            ax.plot([0, 1], [y_bottom, y_bottom], transform=ax.transAxes,
-                    linestyle=':', color='gray', linewidth=0.7)
-
-            # Draw content for each cell in the row
-            content_list = [row['Hall'], row['Index'], row['Movie'], row['Pinyin'], row['TimeStr']]
-            for j, content in enumerate(content_list):
-                x_left = x_coords_ax[j]
-                x_center = x_left + col_widths_ax[j] / 2
-                ax.text(x_center, y_center, content, transform=ax.transAxes,
-                        fontproperties=content_font, ha='center', va='center')
+    plt.close(temp_fig) # 关闭临时figure
+
+    # --- 开始正式绘图 ---
+    figs = {}
+    for fmt in ['png', 'pdf']:
+        fig = plt.figure(figsize=A4_SIZE_INCHES, dpi=DPI)
+        ax = fig.add_subplot(111)
+        ax.set_axis_off()
+        fig.subplots_adjust(left=0, right=1, top=1, bottom=0)
+        ax.set_xlim(0, A4_SIZE_INCHES[0])
+        ax.set_ylim(0, A4_SIZE_INCHES[1])
+
+        # 计算列的 X 轴起始位置
+        x_pos = {}
+        current_x = 0
+        # 新顺序: Hall, Index, Movie, Pinyin, Time
+        col_order = ['Hall', 'Index', 'Movie', 'Pinyin', 'Time']
+        for col in col_order:
+            x_pos[col] = current_x
+            current_x += col_widths[col]
+
+        # 从顶部开始绘制 (顶部留出一行空白)
+        current_y = A4_SIZE_INCHES[1] - row_height_inch 
         
-        # --- Draw Vertical Grid Lines ---
-        content_area_top_y = y_coords_ax[1]
-        content_area_bottom_y = y_coords_ax[-2]
-        for x in x_coords_ax[1:-1]:
-            ax.plot([x, x], [content_area_bottom_y, content_area_top_y], transform=ax.transAxes,
-                    linestyle=':', color='gray', linewidth=0.7)
-
-        # --- Draw Black Separator Lines Between Halls ---
-        hall_change_indices = data.index[data['Hall'] != data['Hall'].shift(-1)]
-        for idx in hall_change_indices:
-            # The line is at the bottom of the current row
-            y_line = y_coords_ax[idx + 2] # +1 for top margin, +1 to get bottom of current row
-            ax.plot([0, 1], [y_line, y_line], transform=ax.transAxes,
-                    linestyle='-', color='black', linewidth=1.2)
-
-
-    # Create figures for PNG and PDF
-    png_fig = plt.figure(figsize=(A4_WIDTH_IN, A4_HEIGHT_IN), dpi=300)
-    pdf_fig = plt.figure(figsize=(A4_WIDTH_IN, A4_HEIGHT_IN), dpi=300)
-    
-    # Configure axes to fill the usable area defined by margins
-    ax_rect = [
-        MARGIN_IN / A4_WIDTH_IN, MARGIN_IN / A4_HEIGHT_IN,
-        USABLE_WIDTH_IN / A4_WIDTH_IN, USABLE_HEIGHT_IN / A4_HEIGHT_IN
-    ]
-    png_ax = png_fig.add_axes(ax_rect)
-    pdf_ax = pdf_fig.add_axes(ax_rect)
-    png_ax.axis('off')
-    pdf_ax.axis('off')
-
-    # Process both figures
-    process_figure(png_fig, png_ax)
-    process_figure(pdf_fig, pdf_ax)
-
-    # Save PNG to buffer
+        halls = sorted(data['Hall'].unique(), key=lambda h: int(h))
+
+        for hall in halls:
+            hall_data = data[data['Hall'] == hall].sort_values('Index')
+            
+            for _, row in hall_data.iterrows():
+                y_bottom = current_y - row_height_inch
+                
+                # 绘制单元格
+                for col_name in col_order:
+                    cell_x = x_pos[col_name]
+                    cell_width = col_widths[col_name]
+                    
+                    # 绘制灰色虚线边框
+                    rect = Rectangle((cell_x, y_bottom), cell_width, row_height_inch,
+                                     edgecolor='lightgray', facecolor='none',
+                                     linestyle=(0, (1, 2)), linewidth=0.8, zorder=1)
+                    ax.add_patch(rect)
+                    
+                    # 准备文本内容
+                    text_content = {
+                        'Hall': f"{row['Hall']}#",
+                        'Index': f"{row['Index']}.",
+                        'Movie': row['Movie'],
+                        'Pinyin': row['Pinyin'],
+                        'Time': row['Time']
+                    }[col_name]
+
+                    # 文本垂直居中
+                    text_y = y_bottom + row_height_inch / 2
+                    
+                    # 电影名列特殊处理
+                    if col_name == 'Movie':
+                        font_to_use = base_font.copy()
+                        # 检查宽度并调整字体
+                        text_w_inch = get_text_width_inch(text_content, font_to_use)
+                        max_w_inch = cell_width * 0.9 # 目标宽度为单元格宽度的90%
+                        if text_w_inch > max_w_inch:
+                            scale_factor = max_w_inch / text_w_inch
+                            font_to_use.set_size(font_size_pt * scale_factor)
+
+                        ax.text(cell_x + cell_width * 0.05, text_y, text_content, # 左对齐
+                                fontproperties=font_to_use, ha='left', va='center', clip_on=True)
+                    else: # 其他列
+                        ax.text(cell_x + cell_width / 2, text_y, text_content, # 居中对齐
+                                fontproperties=base_font, ha='center', va='center', clip_on=True)
+
+                current_y -= row_height_inch
+            
+            # 在每个影厅块结束后绘制黑色分隔线
+            ax.plot([0, A4_SIZE_INCHES[0]], [current_y, current_y], color='black', linewidth=1.5, zorder=2)
+
+        # 在左上角添加日期
+        ax.text(0.1, A4_SIZE_INCHES[1] - 0.3, date_str, 
+                fontproperties=get_font(12), color='gray', ha='left', va='top')
+
+        figs[fmt] = fig
+
+    # 保存到内存
     png_buffer = io.BytesIO()
-    png_fig.savefig(png_buffer, format='png', pad_inches=0)
+    figs['png'].savefig(png_buffer, format='png', dpi=DPI)
     png_buffer.seek(0)
     image_base64 = base64.b64encode(png_buffer.getvalue()).decode()
-    plt.close(png_fig)
+    plt.close(figs['png'])
 
-    # Save PDF to buffer
     pdf_buffer = io.BytesIO()
-    pdf_fig.savefig(pdf_buffer, format='pdf', pad_inches=0)
+    figs['pdf'].savefig(pdf_buffer, format='pdf', dpi=DPI)
     pdf_buffer.seek(0)
     pdf_base64 = base64.b64encode(pdf_buffer.getvalue()).decode()
-    plt.close(pdf_fig)
+    plt.close(figs['pdf'])
 
     return {
         'png': f"data:image/png;base64,{image_base64}",
         'pdf': f"data:application/pdf;base64,{pdf_base64}"
     }
 
-def display_pdf(base64_pdf):
-    """Embeds the PDF in the Streamlit app for display."""
-    pdf_display = f'<iframe src="{base64_pdf}" width="100%" height="800" type="application/pdf"></iframe>'
-    return pdf_display
 
-# --- Streamlit App Main Body ---
+# --- Streamlit UI ---
 st.set_page_config(page_title="LED 屏幕时间表打印", layout="wide")
 st.title("LED 屏幕时间表打印")
+st.markdown("请上传影院系统导出的 `放映时间核对表.xls` 文件。系统将自动处理数据并生成专业、美观的A4打印布局。")
 
-uploaded_file = st.file_uploader("选择打开【放映时间核对表.xls】文件", type=["xls"])
+uploaded_file = st.file_uploader("选择文件", accept_multiple_files=False, type=["xls", "xlsx"])
 
 if uploaded_file:
-    with st.spinner("文件正在处理中，请稍候..."):
+    with st.spinner("文件处理与布局生成中，请稍候..."):
         schedule, date_str = process_schedule(uploaded_file)
         if schedule is not None and not schedule.empty:
             output = create_print_layout(schedule, date_str)
-            if output:
-                # Create tabs to switch between PDF and PNG previews
-                tab1, tab2 = st.tabs(["PDF 预览", "PNG 预览"])
-                
-                with tab1:
-                    st.markdown(display_pdf(output['pdf']), unsafe_allow_html=True)
-                
-                with tab2:
-                    st.image(output['png'], use_container_width=True)
-            else:
-                st.error("生成打印布局失败。")
-        elif schedule is None:
-             st.error("无法处理文件，请检查文件格式或内容是否正确。")
-        else: # schedule is empty
-             st.warning("处理完成，但文件中没有找到有效的排片数据。")
+            
+            st.success(f"成功生成 **{date_str}** 的排片表��")
+
+            # 创建下载按钮
+            col1, col2 = st.columns(2)
+            with col1:
+                 st.download_button(
+                    label="📥 下载 PNG 图像",
+                    data=base64.b64decode(output['png'].split(',')[1]),
+                    file_name=f"排片表_{date_str}.png",
+                    mime="image/png"
+                )
+            with col2:
+                st.download_button(
+                    label="📄 下载 PDF 文档",
+                    data=base64.b64decode(output['pdf'].split(',')[1]),
+                    file_name=f"排片表_{date_str}.pdf",
+                    mime="application/pdf"
+                )
+
+            # 创建选项卡进行预览
+            tab1, tab2 = st.tabs(["📄 PDF 预览", "🖼️ PNG 预览"])
+            
+            with tab1:
+                st.markdown(f'<iframe src="{output["pdf"]}" width="100%" height="800" type="application/pdf"></iframe>', unsafe_allow_html=True)
+            
+            with tab2:
+                st.image(output['png'], use_container_width=True)
+        else:
+            st.error("无法处理文件。请检查文件内容是否为空或格式是否正确。确保文件中包含有效的排片数据。")