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 from pypinyin import lazy_pinyin, Style from matplotlib.backends.backend_pdf import PdfPages def get_font(size=14): """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 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 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 "" # 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): """ 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 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'] # 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+号)') # 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 ) # 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 screenings of the same movie merged_rows = [] 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'] # Extend the end time else: merged_rows.append(current) current = row.copy() if current is not None: merged_rows.append(current) 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', 'Seq', 'Movie', 'StartTime_str', 'EndTime_str']], date_str except Exception as e: st.error(f"Error processing schedule data: {e}. Please check the file format.") return None, date_str def create_print_layout(data, date_str): """ Generates PNG and PDF print layouts for the movie schedule based on a dynamic grid. """ if data is None or data.empty: return None # --- 1. Layout and Column Calculation --- A4_width_in, A4_height_in = 8.27, 11.69 # A4 size in inches dpi = 300 # 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 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'] # 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() # 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 # 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) # 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 # 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] # --- 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() # 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'] # 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') # 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') # 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') # 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') # --- Draw Horizontal Lines --- is_last_in_hall = (i == len(data) - 1) or (row['Hall'] != data.loc[i + 1, 'Hall']) 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) # 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 def display_pdf(base64_pdf): """Generates the HTML to embed a PDF in Streamlit.""" pdf_display = f'' return pdf_display # --- Streamlit App --- 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 '放映时间核对表.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) 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 if the file format and content are correct.")