Update app.py

app.py

@@ -6,309 +6,284 @@ import io
 import base64
 import os
 from datetime import datetime, timedelta
-from matplotlib.patches import Rectangle
+import math
+from matplotlib.patches import FancyBboxPatch, Rectangle
 from pypinyin import lazy_pinyin, Style
 from matplotlib.backends.backend_pdf import PdfPages
 
-# --- 字体设置 ---
 def get_font(size=14):
-    """根据操作系统环境查找并返回中文字体属性"""
-    font_path = "simHei.ttc" # 优先使用 simHei.ttc
+    """Loads the specified font file, falling back to a default."""
+    font_path = "simHei.ttc"
     if not os.path.exists(font_path):
-        font_path = "SimHei.ttf" # SimHei.ttf 作为备选
-    # 如果两者都不存在，可以添加更多备选字体路径
+        font_path = "SimHei.ttf"
     if not os.path.exists(font_path):
-        # 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会回退到默认字体
+        # As a last resort, return default font if SimHei is not found
+        st.warning("Font file 'simHei.ttc' or 'SimHei.ttf' not found. Text may not render correctly.")
+        return font_manager.FontProperties(size=size)
     return font_manager.FontProperties(fname=font_path, size=size)
 
-# --- 拼音处理 ---
 def get_pinyin_abbr(text):
-    """获取文本前两个汉字的拼音首字母"""
-    if not text or not isinstance(text, str):
+    """Gets the first letter of the Pinyin for the first two Chinese characters."""
+    if not text:
         return ""
-    # 提取中文字符
-    chars = [c for c in text if '\u4e00' <= c <= '\u9fff']
-    # 取前两个汉字
-    chars_to_process = chars[:2]
-    if not chars_to_process:
+    chars = [c for c in text if '\u4e00' <= c <= '\u9fff'][:2]
+    if not chars:
         return ""
-    # 获取拼音首字母并转为大写
-    pinyin_list = lazy_pinyin(chars_to_process, style=Style.FIRST_LETTER)
-    return ''.join(pinyin_list).upper()
+    return ''.join(lazy_pinyin(chars, style=Style.FIRST_LETTER)).upper()
 
-# --- 数据处理 ---
 def process_schedule(file):
-    """读取并处理 Excel 文件，返回格式化的 DataFrame 和日期"""
+    """Reads and processes the movie schedule from the uploaded Excel file."""
     try:
-        # 尝试读取日期
+        # Try to read the date from a specific 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:
-        # 读取失败则使用当天日期
-        date_str = datetime.today().strftime('%Y-%m-%d')
+        # Fallback to today's date
         base_date = datetime.today().date()
+        date_str = base_date.strftime('%Y-%m-%d')
 
     try:
-        # 读取排片数据
         df = pd.read_excel(file, header=9, usecols=[1, 2, 4, 5])
         df.columns = ['Hall', 'StartTime', 'EndTime', 'Movie']
-        
-        # 数据清洗
         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)
 
-        # 时间转换
+        # 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 overnight screenings
         df.loc[df['EndTime_dt'] < df['StartTime_dt'], 'EndTime_dt'] += timedelta(days=1)
         df = df.sort_values(['Hall', 'StartTime_dt'])
-        
-        # 合并同一影厅的连续相同影片
+
+        # Merge consecutive shows of the same movie
         merged_rows = []
-        for _, group in df.groupby('Hall'):
-            group = group.sort_values('StartTime_dt')
+        for hall, group in df.groupby('Hall'):
             current = None
-            for _, row in group.iterrows():
+            for _, row in group.sort_values('StartTime_dt').iterrows():
                 if current is None:
                     current = row.copy()
+                elif row['Movie'] == current['Movie']:
+                    current['EndTime_dt'] = row['EndTime_dt']
                 else:
-                    if row['Movie'] == current['Movie']:
-                        current['EndTime_dt'] = row['EndTime_dt']
-                    else:
-                        merged_rows.append(current)
-                        current = row.copy()
+                    merged_rows.append(current)
+                    current = row.copy()
             if current is not None:
                 merged_rows.append(current)
-        
+
         if not merged_rows:
             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)
         
-        # 格式化最终输出的列
-        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)
-        merged_df['Hall'] = merged_df['Hall'].str.replace('号', '')
+        merged_df['StartTime_str'] = merged_df['StartTime_dt'].dt.strftime('%H:%M')
+        merged_df['EndTime_str'] = merged_df['EndTime_dt'].dt.strftime('%H:%M')
         
-        return merged_df[['Hall', 'Movie', 'Pinyin', 'Time']], date_str
-
+        return merged_df[['Hall', 'Movie', 'StartTime_str', 'EndTime_str']], date_str
     except Exception as e:
-        st.error(f"处理 Excel 数据时发生错误: {e}")
+        st.error(f"Error processing the file: {e}")
         return None, date_str
 
+def get_text_dimensions(text, font_props, fig):
+    """Helper function to calculate the width and height of a text string in inches."""
+    renderer = fig.canvas.get_renderer()
+    t = fig.text(0, 0, text, fontproperties=font_props, visible=False)
+    bbox = t.get_window_extent(renderer=renderer)
+    t.remove()
+    return bbox.width / fig.dpi, bbox.height / fig.dpi
+
+def find_font_size(target_height_inches, font_path, fig, text_to_measure="Xg"):
+    """Finds the font size (in points) that results in a given text height (in inches)."""
+    low, high = 0, 100  # Binary search range for font size
+    best_size = 10
+    
+    for _ in range(10):  # 10 iterations for precision
+        mid = (low + high) / 2
+        if mid <= 0: break
+        props = font_manager.FontProperties(fname=font_path, size=mid)
+        _, h = get_text_dimensions(text_to_measure, props, fig)
+        if h > target_height_inches:
+            high = mid
+        else:
+            best_size = mid
+            low = mid
+    return best_size
 
-# --- 打印布局生成 ---
 def create_print_layout(data, date_str):
-    """根据处理好的数据，生成用于打印的 PNG 和 PDF 布局"""
+    """Creates the PNG and PDF print layouts based on the new grid requirements."""
     if data is None or data.empty:
         return None
 
-    A4_SIZE_INCHES = (8.27, 11.69)
-    DPI = 300
+    A4_WIDTH_IN, A4_HEIGHT_IN = 8.27, 11.69
     
-    # 准备一个临时的 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
+    # 1. Layout Calculation
+    total_A = len(data) + 2  # Total rows + top/bottom margin
+    row_height = A4_HEIGHT_IN / total_A
+    side_margin_width = row_height  # Left/right blank columns width
+    content_width = A4_WIDTH_IN - 2 * side_margin_width
+    target_font_height = row_height * 0.9
+
+    # --- Calculate font sizes and column widths ---
+    dummy_fig = plt.figure()
+    font_path = "simHei.ttc" if os.path.exists("simHei.ttc") else "SimHei.ttf"
+    master_font_size = find_font_size(target_font_height, font_path, dummy_fig)
+    master_font = get_font(size=master_font_size)
+
+    # Prepare content to measure for max width
+    data['Pinyin'] = data['Movie'].apply(get_pinyin_abbr)
+    data['TimeStr'] = data['StartTime_str'] + ' - ' + data['EndTime_str']
     
-    # 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
-
-    # 找到每列最长的内容
-    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']
-
-    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
+    max_hall_content = max(data['Hall'].str.replace('号', ''), key=len) + "#"
+    max_seq_content = f"{data.groupby('Hall').size().max()}."
+    max_pinyin_content = max(data['Pinyin'], key=len) if not data['Pinyin'].empty else "PY"
+    max_time_content = max(data['TimeStr'], key=len)
     
-    # 电影名列的宽度为剩余宽度
-    non_movie_width = sum(col_widths.values())
-    col_widths['Movie'] = A4_SIZE_INCHES[0] - non_movie_width
+    w_hall, _ = get_text_dimensions(max_hall_content, master_font, dummy_fig)
+    w_seq, _ = get_text_dimensions(max_seq_content, master_font, dummy_fig)
+    w_pinyin, _ = get_text_dimensions(max_pinyin_content, master_font, dummy_fig)
+    w_time, _ = get_text_dimensions(max_time_content, master_font, dummy_fig)
+    plt.close(dummy_fig)
+
+    col_width_hall = w_hall * 1.1
+    col_width_seq = w_seq * 1.1
+    col_width_pinyin = w_pinyin * 1.1
+    col_width_time = w_time * 1.1
+    
+    col_width_movie = content_width - (col_width_hall + col_width_seq + col_width_pinyin + col_width_time)
 
-    plt.close(temp_fig) # 关闭临时figure
+    if col_width_movie <= 0:
+        st.error("Content is too wide for the page. The movie title column has no space.")
+        return None
 
-    # --- 开始正式绘图 ---
-    figs = {}
+    # --- Create figures for drawing ---
+    output_figs = {}
     for fmt in ['png', 'pdf']:
-        fig = plt.figure(figsize=A4_SIZE_INCHES, dpi=DPI)
+        fig = plt.figure(figsize=(A4_WIDTH_IN, A4_HEIGHT_IN), dpi=300)
         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 
+        ax.set_xlim(0, A4_WIDTH_IN)
+        ax.set_ylim(0, A4_HEIGHT_IN)
+
+        # Define column x-positions (from left to right)
+        x_pos = [0] * 7
+        x_pos[0] = 0
+        x_pos[1] = side_margin_width
+        x_pos[2] = x_pos[1] + col_width_hall
+        x_pos[3] = x_pos[2] + col_width_seq
+        x_pos[4] = x_pos[3] + col_width_movie
+        x_pos[5] = x_pos[4] + col_width_pinyin
+        x_pos[6] = x_pos[5] + col_width_time
+
+        # Add date string to the top margin area
+        ax.text(A4_WIDTH_IN - side_margin_width, A4_HEIGHT_IN - (row_height / 2), date_str,
+                ha='right', va='center', color='#A9A9A9', fontproperties=get_font(12))
+
+        # --- Drawing Loop ---
+        y_cursor = A4_HEIGHT_IN - row_height  # Start below top margin
+        drawn_halls = set()
         
-        halls = sorted(data['Hall'].unique(), key=lambda h: int(h))
+        for hall_name, group in data.groupby('Hall', sort=False):
+            for i, (_, row) in enumerate(group.iterrows()):
+                y_bottom = y_cursor - row_height
+                y_center = y_cursor - (row_height / 2)
+                
+                # Draw dotted cell borders
+                for c in range(5):
+                    ax.add_patch(Rectangle((x_pos[c+1], y_bottom), x_pos[c+2] - x_pos[c+1], row_height,
+                                           facecolor='none', edgecolor='gray', linestyle=':', linewidth=0.5))
+
+                # Column 1: Hall Number (only on first row of the group)
+                if hall_name not in drawn_halls:
+                    hall_num_text = f"${row['Hall'].replace('号', '')}^{{\\#}}$"
+                    ax.text(x_pos[1] + col_width_hall / 2, y_center, hall_num_text,
+                            ha='center', va='center', fontproperties=master_font)
+                    drawn_halls.add(hall_name)
+                
+                # Column 2: Sequence Number
+                ax.text(x_pos[2] + col_width_seq / 2, y_center, f"{i+1}.",
+                        ha='center', va='center', fontproperties=master_font)
 
-        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
+                # Column 3: Movie Title (with font scaling)
+                font_movie = master_font.copy()
+                movie_cell_inner_width = col_width_movie * 0.9
+                
+                temp_fig = plt.figure()
+                w_movie, _ = get_text_dimensions(row['Movie'], font_movie, temp_fig)
+                plt.close(temp_fig)
                 
-                # 绘制单元格
-                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]
+                if w_movie > movie_cell_inner_width:
+                    scale_factor = movie_cell_inner_width / w_movie
+                    font_movie.set_size(font_movie.get_size() * scale_factor)
 
-                    # 文本垂直居中
-                    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(x_pos[3] + col_width_movie * 0.05, y_center, row['Movie'],
+                        ha='left', va='center', fontproperties=font_movie)
 
-                        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)
+                # Column 4: Pinyin Abbreviation
+                ax.text(x_pos[4] + col_width_pinyin / 2, y_center, row['Pinyin'],
+                        ha='center', va='center', fontproperties=master_font)
+                
+                # Column 5: Time
+                ax.text(x_pos[5] + col_width_time / 2, y_center, row['TimeStr'],
+                        ha='center', va='center', fontproperties=master_font)
 
-                current_y -= row_height_inch
+                y_cursor -= row_height
             
-            # 在每个影厅块结束后绘制黑色分隔线
-            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
+            # Draw black separator line below each hall group
+            ax.plot([x_pos[1], x_pos[6]], [y_cursor, y_cursor], color='black', linewidth=1.0)
+        
+        output_figs[fmt] = fig
 
-    # 保存到内存
+    # --- Save figures to in-memory buffers ---
     png_buffer = io.BytesIO()
-    figs['png'].savefig(png_buffer, format='png', dpi=DPI)
+    output_figs['png'].savefig(png_buffer, format='png', bbox_inches=None, pad_inches=0)
+    plt.close(output_figs['png'])
+    
+    pdf_buffer = io.BytesIO()
+    output_figs['pdf'].savefig(pdf_buffer, format='pdf', bbox_inches=None, pad_inches=0)
+    plt.close(output_figs['pdf'])
+    
+    # Encode for display
     png_buffer.seek(0)
     image_base64 = base64.b64encode(png_buffer.getvalue()).decode()
-    plt.close(figs['png'])
-
-    pdf_buffer = io.BytesIO()
-    figs['pdf'].savefig(pdf_buffer, format='pdf', dpi=DPI)
     pdf_buffer.seek(0)
     pdf_base64 = base64.b64encode(pdf_buffer.getvalue()).decode()
-    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):
+    """Generates the HTML to embed a PDF in Streamlit."""
+    return f'<iframe src="{base64_pdf}" width="100%" height="800" type="application/pdf"></iframe>'
 
-# --- Streamlit UI ---
-st.set_page_config(page_title="LED 屏幕时间表打印", layout="wide")
-st.title("LED 屏幕时间表打印")
-st.markdown("请上传影院系统导出的 `放映时间核对表.xls` 文件。系统将自动处理数据并生成专业、美观的A4打印布局。")
+# --- Streamlit App ---
+st.set_page_config(page_title="LED Screen Schedule Printing", layout="wide")
+st.title("LED Screen Schedule Printing")
 
-uploaded_file = st.file_uploader("选择文件", accept_multiple_files=False, type=["xls", "xlsx"])
+uploaded_file = st.file_uploader("Select the 'Screening Time Checklist.xls' file", type=["xls"])
 
 if uploaded_file:
-    with st.spinner("文件处理与布局生成中，请稍候..."):
+    with st.spinner("Processing file, please wait..."):
         schedule, date_str = process_schedule(uploaded_file)
         if schedule is not None and not schedule.empty:
             output = create_print_layout(schedule, date_str)
-            
-            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)
+            if output:
+                tab1, tab2 = st.tabs(["PDF Preview", "PNG Preview"])
+                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("无法处理文件。请检查文件内容是否为空或格式是否正确。确保文件中包含有效的排片数据。")
+            st.error("Could not process the file. Please check that the file format and content are correct.")