Update app.py

app.py

@@ -12,17 +12,12 @@ 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)
 
@@ -30,26 +25,34 @@ 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 format_seq(n):
+    """Converts an integer to a circled number string (e.g., 1 -> ①)."""
+    if not isinstance(n, int) or n <= 0:
+        return str(n)
+    # Unicode characters for circled numbers 1-50
+    circled_chars = "①②③④⑤⑥⑦⑧⑨⑩⑪⑫⑬⑭⑮⑯⑰⑱⑲⑳" \
+                    "㉑㉒㉓㉔㉕㉖㉗㉘㉙㉚㉛㉜㉝㉞㉟" \
+                    "㊱㊲㊳㊴㊵㊶㊷㊸㊹㊺㊻㊼㊽㊾㊿"
+    if 1 <= n <= 50:
+        return circled_chars[n-1]
+    return f'({n})'  # Fallback for numbers greater than 50
+
 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()
 
@@ -57,23 +60,19 @@ def process_schedule(file):
         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
@@ -81,7 +80,7 @@ def process_schedule(file):
                 if current is None:
                     current = row.copy()
                 elif 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()
@@ -90,11 +89,9 @@ def process_schedule(file):
         
         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')
@@ -114,54 +111,52 @@ def create_print_layout(data, date_str):
         return None
 
     # --- 1. Layout and Column Calculation ---
-    A4_width_in, A4_height_in = 8.27, 11.69  # A4 size in inches
+    A4_width_in, A4_height_in = 8.27, 11.69
     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
+    totalA = total_content_rows + 2
     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) + '.'
+    # Format Hall number with LaTeX for superscript
+    data['hall_str'] = '$' + data['Hall'].str.replace('号', '') + '^{\#}$'
+    # Format sequence number as circled character
+    data['seq_str'] = data['Seq'].apply(format_seq)
     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
+    # Specific font size for circled numbers (50% of row height)
+    seq_font_size_pt = (row_height * 0.5) * 72
     
-    def get_col_width_in(series, font_size_pt):
+    def get_col_width_in(series, font_size_pt, is_math=False):
         """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
+        text_width_px, _, _ = renderer.get_text_width_height_descent(max_content, font_prop, ismath=is_math)
         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)
+    # Calculate widths for all columns
+    margin_col_width = row_height
+    # Pass is_math=True for hall number width calculation
+    hall_col_width = get_col_width_in(data['hall_str'], base_font_size_pt, is_math=True)
+    # Use the smaller font size for sequence number width calculation
+    seq_col_width = get_col_width_in(data['seq_str'], seq_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
+    plt.close(temp_fig)
 
-    # 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
@@ -171,33 +166,28 @@ def create_print_layout(data, date_str):
 
     # --- 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
+            line_top_y, line_bottom_y = A4_height_in - row_height, 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
+            y_bottom = A4_height_in - (i + 2) * row_height
+            y_center = y_bottom + row_height / 2
 
             # --- Draw Cell Content ---
-            # Hall Number (only for the first row of each hall)
+            # Hall Number (renders superscript)
             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
+            # Sequence Number (with smaller, specific font size)
             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')
+                    fontproperties=get_font(seq_font_size_pt), ha='center', va='center')
 
             # Pinyin Abbreviation
             ax.text(col_x_starts['pinyin'] + col_widths['pinyin'] / 2, y_center, row['pinyin_abbr'],
@@ -207,43 +197,39 @@ def create_print_layout(data, date_str):
             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 Title (with font scaling)
             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
+            max_width_in = col_widths['movie'] * 0.9
             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
+            ax.text(col_x_starts['movie'] + 0.05, y_center, row['Movie'],
                     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'])
             
+            line_start_x = margin_col_width
+            line_end_x = A4_width_in - margin_col_width
             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))
+                ax.add_line(Line2D([line_start_x, line_end_x], [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 = fig.add_axes([0, 0, 1, 1])
         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')
 
@@ -264,8 +250,7 @@ def create_print_layout(data, date_str):
 
 def display_pdf(base64_pdf):
     """Generates the HTML to embed a PDF in Streamlit."""
-    pdf_display = f'<iframe src="{base64_pdf}" width="100%" height="800" type="application/pdf"></iframe>'
-    return pdf_display
+    return f'<iframe src="{base64_pdf}" width="100%" height="800" type="application/pdf"></iframe>'
 
 # --- Streamlit App ---
 st.set_page_config(page_title="LED Screen Schedule Printer", layout="wide")