Update app.py

app.py

@@ -2,55 +2,66 @@ import pandas as pd
 import streamlit as st
 import matplotlib.pyplot as plt
 import matplotlib.font_manager as font_manager
+from matplotlib.lines import Line2D
 import io
 import base64
 import os
 from datetime import datetime, timedelta
-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):
-    """Loads the specified font file, falling back to a default."""
+    """Loads a specific TrueType font, defaulting to a common Chinese font."""
+    # Prioritize the .ttc file if it exists
     font_path = "simHei.ttc"
     if not os.path.exists(font_path):
+        # Fallback to the .ttf file
         font_path = "SimHei.ttf"
-    if not os.path.exists(font_path):
-        # 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)
+    # If neither exists, matplotlib will use its default font.
+    # For best results, ensure one of these fonts is in the same directory as the script.
+    if os.path.exists(font_path):
+        return font_manager.FontProperties(fname=font_path, size=size)
+    else:
+        # Fallback to a generic font if SimHei is not found
+        st.warning("SimHei font not found. Display may not be correct. Please add simHei.ttc or SimHei.ttf.")
+        return font_manager.FontProperties(family='sans-serif', size=size)
 
 def get_pinyin_abbr(text):
-    """Gets the first letter of the Pinyin for the first two Chinese characters."""
+    """Gets the first letter of the Pinyin for the first two Chinese characters of a text."""
     if not text:
         return ""
+    # Extract the first two Chinese characters
     chars = [c for c in text if '\u4e00' <= c <= '\u9fff'][:2]
     if not chars:
         return ""
-    return ''.join(lazy_pinyin(chars, style=Style.FIRST_LETTER)).upper()
+    # Get the first letter of the pinyin for each character
+    pinyin_list = lazy_pinyin(chars, style=Style.FIRST_LETTER)
+    return ''.join(pinyin_list).upper()
 
 def process_schedule(file):
-    """Reads and processes the movie schedule from the uploaded Excel file."""
+    """
+    Processes the uploaded Excel file to extract and clean the movie schedule data.
+    Adds a sequence number for movies within each hall.
+    """
     try:
-        # Try to read the date from a specific cell
+        # 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
+        # Fallback to today's date if reading fails
+        date_str = datetime.today().strftime('%Y-%m-%d')
         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']
+        
+        # Clean and format the data
         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
@@ -62,228 +73,218 @@ def process_schedule(file):
         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
+        # Merge consecutive screenings of the same movie
         merged_rows = []
-        for hall, group in df.groupby('Hall'):
+        for _, group in df.groupby('Hall'):
             current = None
             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']
+                    current['EndTime_dt'] = row['EndTime_dt'] # Extend the end time
                 else:
                     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)
         
+        # Add a sequence number for each movie within its hall
+        merged_df['Seq'] = merged_df.groupby('Hall').cumcount() + 1
+        
         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', 'StartTime_str', 'EndTime_str']], date_str
+        return merged_df[['Hall', 'Seq', 'Movie', 'StartTime_str', 'EndTime_str']], date_str
     except Exception as e:
-        st.error(f"Error processing the file: {e}")
+        st.error(f"Error processing schedule data: {e}. Please check the file format.")
         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):
-    """Creates the PNG and PDF print layouts based on the new grid requirements."""
+    """
+    Generates PNG and PDF print layouts for the movie schedule based on a dynamic grid.
+    """
     if data is None or data.empty:
         return None
 
-    A4_WIDTH_IN, A4_HEIGHT_IN = 8.27, 11.69
-    
-    # 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
+    # --- 1. Layout and Column Calculation ---
+    A4_width_in, A4_height_in = 8.27, 11.69  # A4 size in inches
+    dpi = 300
 
-    # --- 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)
+    # Calculate total rows and row height based on A4 size
+    total_content_rows = len(data)
+    totalA = total_content_rows + 2  # Add 2 for top/bottom margin rows
+    row_height = A4_height_in / totalA
 
-    # Prepare content to measure for max width
-    data['Pinyin'] = data['Movie'].apply(get_pinyin_abbr)
-    data['TimeStr'] = data['StartTime_str'] + ' - ' + data['EndTime_str']
-    
-    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)
-    
-    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)
+    # Prepare data strings for width calculation
+    data = data.reset_index(drop=True)
+    data['hall_str'] = data['Hall'].str.replace('号', '') + '#'
+    data['seq_str'] = data['Seq'].astype(str) + '.'
+    data['pinyin_abbr'] = data['Movie'].apply(get_pinyin_abbr)
+    data['time_str'] = data['StartTime_str'] + ' - ' + data['EndTime_str']
 
-    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)
+    # Create a temporary figure to access the renderer for text width calculation
+    temp_fig = plt.figure(figsize=(A4_width_in, A4_height_in), dpi=dpi)
+    renderer = temp_fig.canvas.get_renderer()
 
-    if col_width_movie <= 0:
-        st.error("Content is too wide for the page. The movie title column has no space.")
-        return None
+    # Base font size is 90% of the row height (converted from inches to points)
+    base_font_size_pt = (row_height * 0.9) * 72
+    
+    def get_col_width_in(series, font_size_pt):
+        """Calculates the required width for a column in inches."""
+        if series.empty:
+            return 0
+        font_prop = get_font(font_size_pt)
+        # Find the string with the maximum visual length in the series
+        longest_str_idx = series.astype(str).str.len().idxmax()
+        max_content = str(series.loc[longest_str_idx])
+        # Get width in pixels from the renderer
+        text_width_px, _, _ = renderer.get_text_width_height_descent(max_content, font_prop, ismath=False)
+        # Convert to inches and add a 10% buffer
+        return (text_width_px / dpi) * 1.1
 
-    # --- Create figures for drawing ---
-    output_figs = {}
-    for fmt in ['png', 'pdf']:
-        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_WIDTH_IN)
-        ax.set_ylim(0, A4_HEIGHT_IN)
+    # Calculate widths for fixed-content columns
+    margin_col_width = row_height # Left/right margins are as wide as the rows are high
+    hall_col_width = get_col_width_in(data['hall_str'], base_font_size_pt)
+    seq_col_width = get_col_width_in(data['seq_str'], base_font_size_pt)
+    pinyin_col_width = get_col_width_in(data['pinyin_abbr'], base_font_size_pt)
+    time_col_width = get_col_width_in(data['time_str'], base_font_size_pt)
 
-        # 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
+    # The movie title column takes the remaining width
+    movie_col_width = A4_width_in - (margin_col_width * 2 + hall_col_width + seq_col_width + pinyin_col_width + time_col_width)
+    
+    plt.close(temp_fig)  # Close the temporary figure
 
-        # 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))
+    # Store column widths and their horizontal starting positions
+    col_widths = {'hall': hall_col_width, 'seq': seq_col_width, 'movie': movie_col_width, 'pinyin': pinyin_col_width, 'time': time_col_width}
+    col_x_starts = {}
+    current_x = margin_col_width
+    for col_name in ['hall', 'seq', 'movie', 'pinyin', 'time']:
+        col_x_starts[col_name] = current_x
+        current_x += col_widths[col_name]
 
-        # --- Drawing Loop ---
-        y_cursor = A4_HEIGHT_IN - row_height  # Start below top margin
-        drawn_halls = set()
+    # --- 2. Drawing ---
+    def draw_figure(fig, ax):
+        """The common drawing function to be applied to both PNG and PDF figures."""
+        # Get a renderer from the actual figure we are drawing on
+        renderer = fig.canvas.get_renderer()
         
-        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))
+        # Draw vertical dotted grid lines between columns
+        for col_name in ['hall', 'seq', 'movie', 'pinyin']:
+            x_line = col_x_starts[col_name] + col_widths[col_name]
+            line_top_y = A4_height_in - row_height
+            line_bottom_y = row_height
+            ax.add_line(Line2D([x_line, x_line], [line_bottom_y, line_top_y], color='gray', linestyle=':', linewidth=0.5))
+
+        # --- Draw Content and Horizontal Lines for each row ---
+        last_hall_drawn = None
+        for i, row in data.iterrows():
+            y_bottom = A4_height_in - (i + 2) * row_height  # Y-coordinate of the row's bottom line
+            y_center = y_bottom + row_height / 2              # Y-coordinate of the row's vertical center
+
+            # --- Draw Cell Content ---
+            # Hall Number (only for the first row of each hall)
+            if row['Hall'] != last_hall_drawn:
+                ax.text(col_x_starts['hall'] + col_widths['hall'] / 2, y_center, row['hall_str'],
+                        fontproperties=get_font(base_font_size_pt), ha='center', va='center')
+                last_hall_drawn = row['Hall']
 
-                # 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)
+            # Sequence Number
+            ax.text(col_x_starts['seq'] + col_widths['seq'] / 2, y_center, row['seq_str'],
+                    fontproperties=get_font(base_font_size_pt), ha='center', va='center')
 
-                # 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)
-                
-                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)
+            # Pinyin Abbreviation
+            ax.text(col_x_starts['pinyin'] + col_widths['pinyin'] / 2, y_center, row['pinyin_abbr'],
+                    fontproperties=get_font(base_font_size_pt), ha='center', va='center')
 
-                ax.text(x_pos[3] + col_width_movie * 0.05, y_center, row['Movie'],
-                        ha='left', va='center', fontproperties=font_movie)
+            # Time String
+            ax.text(col_x_starts['time'] + col_widths['time'] / 2, y_center, row['time_str'],
+                    fontproperties=get_font(base_font_size_pt), ha='center', va='center')
 
-                # 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)
+            # Movie Title (with special font scaling to fit)
+            movie_font_size = base_font_size_pt
+            movie_font_prop = get_font(movie_font_size)
+            text_w_px, _, _ = renderer.get_text_width_height_descent(row['Movie'], movie_font_prop, ismath=False)
+            text_w_in = text_w_px / dpi
+            
+            max_width_in = col_widths['movie'] * 0.9 # Target 90% of cell width
+            if text_w_in > max_width_in:
+                # If text is too wide, reduce font size proportionally
+                movie_font_size *= (max_width_in / text_w_in)
+                movie_font_prop = get_font(movie_font_size)
+            
+            ax.text(col_x_starts['movie'] + 0.05, y_center, row['Movie'], # Left-aligned with padding
+                    fontproperties=movie_font_prop, ha='left', va='center')
 
-                y_cursor -= row_height
+            # --- Draw Horizontal Lines ---
+            is_last_in_hall = (i == len(data) - 1) or (row['Hall'] != data.loc[i + 1, 'Hall'])
             
-            # 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)
+            if is_last_in_hall:
+                # Draw a solid black line to separate halls
+                line_start_x = margin_col_width
+                line_end_x = A4_width_in - margin_col_width
+                ax.add_line(Line2D([line_start_x, line_end_x], [y_bottom, y_bottom], color='black', linestyle='-', linewidth=0.8))
+            else:
+                # Draw a dotted gray line for rows within a hall
+                ax.add_line(Line2D([margin_col_width, A4_width_in - margin_col_width], [y_bottom, y_bottom], color='gray', linestyle=':', linewidth=0.5))
+
+    # --- 3. Setup Figures and Generate Output ---
+    outputs = {}
+    for format_type in ['png', 'pdf']:
+        fig = plt.figure(figsize=(A4_width_in, A4_height_in), dpi=dpi)
+        ax = fig.add_axes([0, 0, 1, 1])  # Use the whole figure area for drawing
+        ax.set_axis_off()
+        ax.set_xlim(0, A4_width_in)
+        ax.set_ylim(0, A4_height_in)
         
-        output_figs[fmt] = fig
+        # Add date string to the top margin area
+        ax.text(margin_col_width, A4_height_in - (row_height/2), date_str, 
+                fontproperties=get_font(10), color='#A9A9A9', ha='left', va='center')
+
+        draw_figure(fig, ax)
+        
+        buf = io.BytesIO()
+        fig.savefig(buf, format=format_type, dpi=dpi, bbox_inches='tight', pad_inches=0)
+        buf.seek(0)
+        
+        data_uri = base64.b64encode(buf.getvalue()).decode()
+        mime_type = 'image/png' if format_type == 'png' else 'application/pdf'
+        outputs[format_type] = f"data:{mime_type};base64,{data_uri}"
+        
+        plt.close(fig)
+
+    return outputs
 
-    # --- Save figures to in-memory buffers ---
-    png_buffer = io.BytesIO()
-    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()
-    pdf_buffer.seek(0)
-    pdf_base64 = base64.b64encode(pdf_buffer.getvalue()).decode()
-    
-    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>'
+    pdf_display = f'<iframe src="{base64_pdf}" width="100%" height="800" type="application/pdf"></iframe>'
+    return pdf_display
 
 # --- Streamlit App ---
-st.set_page_config(page_title="LED Screen Schedule Printing", layout="wide")
-st.title("LED Screen Schedule Printing")
+st.set_page_config(page_title="LED Screen Schedule Printer", layout="wide")
+st.title("LED Screen Schedule Printer")
 
-uploaded_file = st.file_uploader("Select the 'Screening Time Checklist.xls' file", type=["xls"])
+uploaded_file = st.file_uploader("Select the '放映时间核对表.xls' file", accept_multiple_files=False, type=["xls", "xlsx"])
 
 if uploaded_file:
     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)
-            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)
+            
+            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("Could not process the file. Please check that the file format and content are correct.")
+            st.error("Could not process the file. Please check if the file format and content are correct.")