Update app.py

app.py

@@ -11,31 +11,34 @@ from pypinyin import lazy_pinyin, Style
 from matplotlib.backends.backend_pdf import PdfPages
 
 def get_font(size=14):
-    """Loads a specific font file, falling back to a default if not found."""
+    """Loads a font file, searching for common names."""
     font_path = "simHei.ttc"
     if not os.path.exists(font_path):
-        font_path = "SimHei.ttf" # Fallback font
+        font_path = "SimHei.ttf"
     return font_manager.FontProperties(fname=font_path, size=size)
 
 def get_pinyin_abbr(text):
-    """Generates a two-letter pinyin abbreviation from the first two Chinese characters of a 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']
-    chars = chars[:2]
-    # Get the first letter of the pinyin for each character
+    if len(chars) < 2:
+        chars = chars + [''] * (2 - len(chars))
+    else:
+        chars = chars[:2]
+    # Get the first letter of the Pinyin
     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 movie schedule data."""
+    """Processes the uploaded Excel file to extract and clean schedule data."""
     try:
-        # Attempt to read the date from the Excel file
+        # 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:
+    except:
         # Fallback to the current date if reading fails
         date_str = datetime.today().strftime('%Y-%m-%d')
         base_date = datetime.today().date()
@@ -44,8 +47,6 @@ def process_schedule(file):
         # Read the main schedule data
         df = pd.read_excel(file, header=9, usecols=[1, 2, 4, 5])
         df.columns = ['Hall', 'StartTime', 'EndTime', 'Movie']
-        
-        # Clean and process 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+号)')
@@ -57,24 +58,24 @@ def process_schedule(file):
         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'):
+        for hall, group in df.groupby('Hall'):
             group = group.sort_values('StartTime_dt')
             current = None
             for _, row in group.iterrows():
                 if current is None:
                     current = row.copy()
-                elif row['Movie'] == current['Movie']:
-                    current['EndTime_dt'] = row['EndTime_dt']
                 else:
-                    merged_rows.append(current)
-                    current = row.copy()
+                    if row['Movie'] == current['Movie']:
+                        current['EndTime_dt'] = row['EndTime_dt']
+                    else:
+                        merged_rows.append(current)
+                        current = row.copy()
             if current is not None:
                 merged_rows.append(current)
         
@@ -88,115 +89,115 @@ def process_schedule(file):
         merged_df['EndTime_str'] = merged_df['EndTime_dt'].dt.strftime('%H:%M')
         
         return merged_df[['Hall', 'Movie', 'StartTime_str', 'EndTime_str']], date_str
-    except Exception as e:
-        st.error(f"Error processing file: {e}")
+    except:
         return None, date_str
 
 def create_print_layout(data, date_str):
-    """Creates the PNG and PDF print layouts from the processed schedule data."""
+    """Creates the PNG and PDF print layouts from the schedule data."""
     if data is None or data.empty:
         return None
     
-    # --- Figure Setup for PNG and PDF ---
+    # Create PNG image for preview
     png_fig = plt.figure(figsize=(8.27, 11.69), dpi=300)
     png_ax = png_fig.add_subplot(111)
     png_ax.set_axis_off()
     png_fig.subplots_adjust(left=0.02, right=0.98, top=0.98, bottom=0.02)
     
+    # Create PDF image for download
     pdf_fig = plt.figure(figsize=(8.27, 11.69), dpi=300)
     pdf_ax = pdf_fig.add_subplot(111)
     pdf_ax.set_axis_off()
     pdf_fig.subplots_adjust(left=0.02, right=0.98, top=0.98, bottom=0.02)
-
-    def process_figure(fig, ax):
-        """Helper function to draw the schedule on a given matplotlib figure axis."""
-        # --- Dynamic Height and Font Size Calculation ---
-        halls = sorted(data['Hall'].unique(), key=lambda h: int(h.replace('号', '')))
-        num_movies = len(data)
-        num_separators = len(halls) - 1 if len(halls) > 1 else 0
-
-        # Total vertical slots = movies + separators + 2 for padding
-        total_slots = num_movies + num_separators + 2
-        available_height = 0.96  # Usable page height (0.98 top - 0.02 bottom)
-        line_height = available_height / total_slots
-        
-        # Convert figure line height to font points (72 points per inch)
-        fig_height_inches = fig.get_figheight()
-        font_size_pt = (fig_height_inches * line_height) * 72 * 0.90 # 90% of line height
-
-        movie_font = get_font(font_size_pt)
-        hall_font = get_font(font_size_pt) # Use the same size for impact
+    
+    def process_figure(fig, ax, is_pdf=False):
+        """Shared function to draw the schedule on a matplotlib figure."""
         date_font = get_font(12)
+        
+        # Calculate row height to fill the page
+        total_movies = len(data)
+        # Add 2 to the total to create top and bottom margins
+        total_divisions = total_movies + 2 
+        
+        available_height_ax = 0.98 - 0.02  # Use 96% of the page height
+        row_height_ax = available_height_ax / total_divisions
 
-        ax.text(0.01, 0.99, date_str, fontsize=12, color='#A9A9A9',
-                ha='left', va='top', fontproperties=date_font, transform=ax.transAxes)
+        # Convert relative height to point size for fonts
+        fig_height_pts = fig.get_figheight() * 72
+        row_height_pts = row_height_ax * fig_height_pts
+        
+        # Set font size to 90% of the calculated row height
+        font_size = row_height_pts * 0.9
+        hall_font_size = font_size * 0.8
         
-        y_position = 0.98
+        hall_font = get_font(hall_font_size)
+        movie_font = get_font(font_size)
+        
+        # Add date stamp to the top left
+        ax.text(0.00, 1.00, date_str, fontsize=12, color='#A9A9A9',
+                ha='left', va='top', fontproperties=date_font, transform=ax.transAxes, zorder=2)
+        
+        halls = sorted(data['Hall'].unique(), key=lambda h: int(h.replace('号','')) if h else 0)
+        
+        # Start drawing from the top, leaving one row_height as a margin
+        y_position = 0.98 - row_height_ax
         
         for i, hall in enumerate(halls):
             hall_data = data[data['Hall'] == hall]
-            hall_num_text = f"${hall.replace('号', '')}^{{\\#}}$" # Format hall number with #
-            
+            hall_num = hall.replace("号", "")
+            hall_text = f"${hall_num}^{{\\#}}$"
             movie_count = 1
+            
             for _, row in hall_data.iterrows():
-                # --- Content Layout and Alignment ---
-                # Hall number is printed only for the first movie of the hall
+                # Hall Number (left-aligned)
                 if movie_count == 1:
-                    ax.text(0.03, y_position, hall_num_text,
-                            fontsize=font_size_pt, fontweight='bold', ha='left', va='top',
-                            fontproperties=hall_font, transform=ax.transAxes)
-
+                    ax.text(0.03, y_position, hall_text,
+                            fontsize=hall_font_size, fontweight='bold',
+                            ha='left', va='top', fontproperties=hall_font,
+                            transform=ax.transAxes, zorder=2)
+                
                 pinyin_abbr = get_pinyin_abbr(row['Movie'])
-                time_str = f"{row['StartTime_str']} - {row['EndTime_str']}"
-
-                # Define x-coordinates for each column
-                x_movie_name_end = 0.48
-                x_seq_no_start = 0.51
-                x_pinyin_start = 0.62
-                x_time_start = 0.75
                 
-                # Movie Name (Right-aligned)
-                ax.text(x_movie_name_end, y_position, row['Movie'],
-                        fontsize=font_size_pt, ha='right', va='top',
-                        fontproperties=movie_font, transform=ax.transAxes)
+                # New content order and alignment
+                # 1. Movie Name (right-aligned)
+                ax.text(0.55, y_position, row['Movie'],
+                        fontsize=font_size, ha='right', va='top', fontproperties=movie_font,
+                        transform=ax.transAxes, zorder=2)
                 
-                # Sequence Number (Left-aligned)
-                ax.text(x_seq_no_start, y_position, f"{movie_count}.",
-                        fontsize=font_size_pt, ha='left', va='top',
-                        fontproperties=movie_font, transform=ax.transAxes)
+                # 2. Sequence Number (left-aligned)
+                ax.text(0.57, y_position, f"{movie_count}.",
+                        fontsize=font_size, ha='left', va='top', fontproperties=movie_font,
+                        transform=ax.transAxes, zorder=2)
                 
-                # Pinyin Abbreviation (Left-aligned)
-                ax.text(x_pinyin_start, y_position, pinyin_abbr,
-                        fontsize=font_size_pt, ha='left', va='top',
-                        fontproperties=movie_font, transform=ax.transAxes)
-
-                # Time (Left-aligned)
-                ax.text(x_time_start, y_position, time_str,
-                        fontsize=font_size_pt, ha='left', va='top',
-                        fontproperties=movie_font, transform=ax.transAxes)
+                # 3. Pinyin Abbreviation (left-aligned)
+                ax.text(0.63, y_position, pinyin_abbr,
+                        fontsize=font_size, ha='left', va='top', fontproperties=movie_font,
+                        transform=ax.transAxes, zorder=2)
+                        
+                # 4. Time (left-aligned)
+                ax.text(0.72, y_position, f"{row['StartTime_str']} - {row['EndTime_str']}",
+                        fontsize=font_size, ha='left', va='top', fontproperties=movie_font,
+                        transform=ax.transAxes, zorder=2)
                 
-                y_position -= line_height
+                y_position -= row_height_ax
                 movie_count += 1
             
-            # --- Hall Separator Line ---
-            if i < num_separators:
-                # Draw a black line to separate halls
-                ax.axhline(y=y_position + (line_height / 2), xmin=0.02, xmax=0.98,
-                           color='black', linewidth=0.8, transform=ax.transAxes)
-                y_position -= line_height # Add space for the separator line
+            # Draw a black line to separate halls
+            if i < len(halls) - 1:
+                line_y = y_position + (row_height_ax / 2)
+                ax.plot([0.03, 0.97], [line_y, line_y], color='black', linewidth=1, transform=ax.transAxes, zorder=1)
 
-    # Generate both PNG and PDF outputs
+    # Process both the PNG and PDF figures
     process_figure(png_fig, png_ax)
-    process_figure(pdf_fig, pdf_ax)
-
-    # Save PNG to a memory buffer
+    process_figure(pdf_fig, pdf_ax, is_pdf=True)
+    
+    # Save PNG to buffer
     png_buffer = io.BytesIO()
     png_fig.savefig(png_buffer, format='png', bbox_inches='tight', pad_inches=0.05)
     png_buffer.seek(0)
     image_base64 = base64.b64encode(png_buffer.getvalue()).decode()
     plt.close(png_fig)
     
-    # Save PDF to a memory buffer
+    # Save PDF to buffer
     pdf_buffer = io.BytesIO()
     with PdfPages(pdf_buffer) as pdf:
         pdf.savefig(pdf_fig, bbox_inches='tight', pad_inches=0.05)
@@ -210,11 +211,13 @@ def create_print_layout(data, date_str):
     }
 
 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>'
+    """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
 
-# --- Streamlit App Main Interface ---
+# --- Streamlit App ---
 st.set_page_config(page_title="LED 屏幕时间表打印", layout="wide")
 st.title("LED 屏幕时间表打印")