File size: 19,427 Bytes
e522499
 
 
a1d5478
 
e522499
 
a1d5478
 
 
 
79debab
e522499
 
a1d5478
e522499
 
 
a1d5478
e522499
1ca624e
 
 
 
a1d5478
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
e522499
b7d31cf
a1d5478
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1ca624e
a1d5478
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
7704499
 
89e2a2e
cd91a84
e522499
cd91a84
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
a1d5478
 
cd91a84
 
 
89e2a2e
 
 
 
 
 
79debab
1ca624e
79debab
 
a1d5478
 
 
 
79debab
e522499
 
 
 
 
 
 
 
cd91a84
e522499
79debab
e522499
 
a1d5478
 
28f28d0
 
95f254d
1ca624e
 
 
 
 
 
 
 
 
 
 
 
 
 
89e2a2e
1ca624e
a1d5478
1ca624e
 
a1d5478
1ca624e
 
 
8319975
1ca624e
8319975
1ca624e
8319975
 
 
 
 
1ca624e
8319975
 
 
 
a1d5478
1ca624e
8319975
89e2a2e
 
a1d5478
89e2a2e
a1d5478
89e2a2e
8319975
89e2a2e
8319975
89e2a2e
8319975
 
 
1ca624e
8319975
1ca624e
a1d5478
1ca624e
89e2a2e
8319975
a1d5478
1ca624e
 
 
 
e522499
a1d5478
e522499
 
 
8319975
a1d5478
e522499
 
a1d5478
e522499
 
 
 
 
 
a1d5478
 
e522499
a1d5478
 
 
e522499
a1d5478
 
e522499
 
a1d5478
 
 
 
 
 
 
 
 
 
 
e522499
a1d5478
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
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
import matplotlib.gridspec as gridspec
import math

# --- Constants for the second script ---
SPLIT_TIME = "17:30"
BUSINESS_START = "09:30"
BUSINESS_END = "01:30"
BORDER_COLOR = 'grey'
DATE_COLOR = '#A9A9A9'
A5_WIDTH_IN = 5.83
A5_HEIGHT_IN = 8.27
NUM_COLS = 3

# --- Functions from the first script ---
def get_font(size=14):
    """Loads a specific TrueType font, defaulting to a common Chinese font."""
    font_path = "simHei.ttc"
    if not os.path.exists(font_path):
        font_path = "SimHei.ttf"
    if os.path.exists(font_path):
        return font_manager.FontProperties(fname=font_path, size=size)
    else:
        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 ""
    chars = [c for c in text if '\u4e00' <= c <= '\u9fff'][:2]
    if not chars:
        return ""
    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)
    circled_chars = "①②③④⑤⑥⑦⑧⑨⑩⑪⑫⑬⑭⑮⑯⑰⑱⑲⑳" \
                    "㉑㉒㉓㉔㉕㉖㉗㉘㉙㉚㉛㉜㉝㉞㉟" \
                    "㊱㊲㊳㊴㊵㊶㊷㊸㊹㊺㊻㊼㊽㊾㊿"
    if 1 <= n <= 50:
        return circled_chars[n - 1]
    return f'({n})'

def process_schedule_led(file):
    """Processes '放映时间核对表.xls'."""
    try:
        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')
        base_date = datetime.today().date()

    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['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.loc[df['EndTime_dt'] < df['StartTime_dt'], 'EndTime_dt'] += timedelta(days=1)
        df = df.sort_values(['Hall', 'StartTime_dt'])
        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']
                else:
                    merged_rows.append(current)
                    current = row.copy()
            if current is not None:
                merged_rows.append(current)
        merged_df = pd.DataFrame(merged_rows)
        merged_df['StartTime_dt'] -= timedelta(minutes=10)
        merged_df['EndTime_dt'] -= timedelta(minutes=5)
        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_led(data, date_str):
    """Generates print layouts for '放映时间核对表.xls'."""
    if data is None or data.empty:
        return None
    A4_width_in, A4_height_in = 8.27, 11.69
    dpi = 300
    total_content_rows = len(data)
    totalA = total_content_rows + 2
    row_height = A4_height_in / totalA
    data = data.reset_index(drop=True)
    data['hall_str'] = '$' + data['Hall'].str.replace('号', '') + '^{\#}$'
    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']
    temp_fig = plt.figure(figsize=(A4_width_in, A4_height_in), dpi=dpi)
    renderer = temp_fig.canvas.get_renderer()
    base_font_size_pt = (row_height * 0.9) * 72
    seq_font_size_pt = (row_height * 0.5) * 72

    def get_col_width_in(series, font_size_pt, is_math=False):
        if series.empty:
            return 0
        font_prop = get_font(font_size_pt)
        longest_str_idx = series.astype(str).str.len().idxmax()
        max_content = str(series.loc[longest_str_idx])
        text_width_px, _, _ = renderer.get_text_width_height_descent(max_content, font_prop, ismath=is_math)
        return (text_width_px / dpi) * 1.1

    margin_col_width = row_height
    hall_col_width = get_col_width_in(data['hall_str'], base_font_size_pt, is_math=True)
    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)
    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)
    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]

    def draw_figure(fig, ax):
        renderer = fig.canvas.get_renderer()
        for col_name in ['hall', 'seq', 'movie', 'pinyin']:
            x_line = col_x_starts[col_name] + col_widths[col_name]
            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))
        last_hall_drawn = None
        for i, row in data.iterrows():
            y_bottom = A4_height_in - (i + 2) * row_height
            y_center = y_bottom + row_height / 2
            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']
            ax.text(col_x_starts['seq'] + col_widths['seq'] / 2, y_center, row['seq_str'],
                    fontproperties=get_font(seq_font_size_pt), ha='center', va='center')
            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(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_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
            if text_w_in > max_width_in:
                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'],
                    fontproperties=movie_font_prop, ha='left', va='center')
            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:
                ax.add_line(Line2D([line_start_x, line_end_x], [y_bottom, y_bottom], color='black', linestyle='-',
                                   linewidth=0.8))
            else:
                ax.add_line(Line2D([line_start_x, line_end_x], [y_bottom, y_bottom], color='gray', linestyle=':',
                                   linewidth=0.5))

    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])
        ax.set_axis_off()
        ax.set_xlim(0, A4_width_in)
        ax.set_ylim(0, A4_height_in)
        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

# --- Functions from the second script ---
def process_schedule_times(file):
    """Processes '放映场次核对表.xls'."""
    try:
        df = pd.read_excel(file, skiprows=8)
        df = df.iloc[:, [6, 7, 9]]
        df.columns = ['Hall', 'StartTime', 'EndTime']
        df = df.dropna(subset=['Hall', 'StartTime', 'EndTime'])
        df['Hall'] = df['Hall'].str.extract(r'(\d+)号').astype(str) + ' '
        df['original_end'] = df['EndTime']
        base_date = datetime.today().date()
        df['StartTime'] = pd.to_datetime(df['StartTime'])
        df['EndTime'] = pd.to_datetime(df['EndTime'])
        business_start = datetime.strptime(f"{base_date} {BUSINESS_START}", "%Y-%m-%d %H:%M")
        business_end = datetime.strptime(f"{base_date} {BUSINESS_END}", "%Y-%m-%d %H:%M")
        if business_end < business_start:
            business_end += timedelta(days=1)
        for idx, row in df.iterrows():
            end_time = row['EndTime']
            if end_time.hour < 9:
                df.at[idx, 'EndTime'] = end_time + timedelta(days=1)
            if row['StartTime'].hour >= 21 and end_time.hour < 9:
                df.at[idx, 'EndTime'] = end_time + timedelta(days=1)
        df['time_for_comparison'] = df['EndTime'].apply(
            lambda x: datetime.combine(base_date, x.time())
        )
        df.loc[df['time_for_comparison'].dt.hour < 9, 'time_for_comparison'] += timedelta(days=1)
        valid_times = (
                ((df['time_for_comparison'] >= datetime.combine(base_date, business_start.time())) &
                 (df['time_for_comparison'] <= datetime.combine(base_date + timedelta(days=1), business_end.time())))
        )
        df = df[valid_times]
        df = df.sort_values('EndTime')
        split_time = datetime.strptime(f"{base_date} {SPLIT_TIME}", "%Y-%m-%d %H:%M")
        split_time_for_comparison = df['time_for_comparison'].apply(
            lambda x: datetime.combine(base_date, split_time.time())
        )
        part1 = df[df['time_for_comparison'] <= split_time_for_comparison].copy()
        part2 = df[df['time_for_comparison'] > split_time_for_comparison].copy()
        for part in [part1, part2]:
            part['EndTime'] = part['EndTime'].dt.strftime('%-H:%M')
        date_df = pd.read_excel(
            file,
            skiprows=5,
            nrows=1,
            usecols=[2],
            header=None
        )
        date_cell = date_df.iloc[0, 0]
        try:
            if isinstance(date_cell, str):
                date_str = datetime.strptime(date_cell, '%Y-%m-%d').strftime('%Y-%m-%d')
            else:
                date_str = pd.to_datetime(date_cell).strftime('%Y-%m-%d')
        except:
            date_str = datetime.today().strftime('%Y-%m-%d')
        return part1[['Hall', 'EndTime']], part2[['Hall', 'EndTime']], date_str
    except Exception as e:
        st.error(f"处理文件时出错: {str(e)}")
        return None, None, None

def create_print_layout_times(data, title, date_str):
    """Creates print layouts for '放映场次核对表.xls'."""
    if data.empty:
        return None

    def generate_figure():
        total_items = len(data)
        num_rows = math.ceil(total_items / NUM_COLS) if total_items > 0 else 1
        date_header_height_in = 0.3
        data_area_height_in = A5_HEIGHT_IN - date_header_height_in
        cell_width_in = A5_WIDTH_IN / NUM_COLS
        cell_height_in = data_area_height_in / num_rows
        cell_width_pt = cell_width_in * 72
        cell_height_pt = cell_height_in * 72
        target_text_width_pt = cell_width_pt * 0.9
        fontsize_from_width = target_text_width_pt / (8 * 0.6)
        fontsize_from_height = cell_height_pt * 0.8
        base_fontsize = min(fontsize_from_width, fontsize_from_height)
        fig = plt.figure(figsize=(A5_WIDTH_IN, A5_HEIGHT_IN), dpi=300)
        fig.subplots_adjust(left=0, right=1, top=1, bottom=0)
        plt.rcParams['font.family'] = 'sans-serif'
        plt.rcParams['font.sans-serif'] = ['Arial Unicode MS']
        gs = gridspec.GridSpec(
            num_rows + 1, NUM_COLS,
            hspace=0, wspace=0,
            height_ratios=[date_header_height_in] + [cell_height_in] * num_rows,
            figure=fig
        )
        data_values = data.values.tolist()
        while len(data_values) % NUM_COLS != 0:
            data_values.append(['', ''])
        rows_per_col_layout = math.ceil(len(data_values) / NUM_COLS)
        sorted_data = [['', '']] * len(data_values)
        for i, item in enumerate(data_values):
            if item[0] and item[1]:
                row_in_col = i % rows_per_col_layout
                col_idx = i // rows_per_col_layout
                new_index = row_in_col * NUM_COLS + col_idx
                if new_index < len(sorted_data):
                    sorted_data[new_index] = item
        for idx, (hall, end_time) in enumerate(sorted_data):
            if hall and end_time:
                row_grid = idx // NUM_COLS + 1
                col_grid = idx % NUM_COLS
                ax = fig.add_subplot(gs[row_grid, col_grid])
                for spine in ax.spines.values():
                    spine.set_visible(True)
                    spine.set_linestyle((0, (1, 2)))
                    spine.set_color(BORDER_COLOR)
                    spine.set_linewidth(0.75)
                display_text = f"{hall}{end_time}"
                ax.text(0.5, 0.5, display_text,
                        fontsize=base_fontsize,
                        fontweight='bold',
                        ha='center', va='center',
                        transform=ax.transAxes)
                ax.set_xticks([])
                ax.set_yticks([])
                ax.set_facecolor('none')
        ax_date = fig.add_subplot(gs[0, :])
        ax_date.text(0.01, 0.5, f"{date_str} {title}",
                     fontsize=base_fontsize * 0.5,
                     color=DATE_COLOR, fontweight='bold',
                     ha='left', va='center',
                     transform=ax_date.transAxes)
        ax_date.set_axis_off()
        ax_date.set_facecolor('none')
        return fig

    fig_for_output = generate_figure()
    png_buffer = io.BytesIO()
    fig_for_output.savefig(png_buffer, format='png')
    png_buffer.seek(0)
    png_base64 = base64.b64encode(png_buffer.getvalue()).decode()
    pdf_buffer = io.BytesIO()
    with PdfPages(pdf_buffer) as pdf:
        pdf.savefig(fig_for_output)
    pdf_buffer.seek(0)
    pdf_base64 = base64.b64encode(pdf_buffer.getvalue()).decode()
    plt.close(fig_for_output)
    return {
        'png': f'data:image/png;base64,{png_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 App ---
st.set_page_config(page_title="Schedule Printer", layout="wide")
st.title("Schedule Printer")

uploaded_file = st.file_uploader("Select '放映时间核对表.xls' or '放映场次核对表.xls'",
                                 type=["xls", "xlsx"])

if uploaded_file:
    if "时间" in uploaded_file.name:
        st.header("LED Screen Schedule")
        with st.spinner("Processing file, please wait..."):
            schedule, date_str = process_schedule_led(uploaded_file)
            if schedule is not None and not schedule.empty:
                output = create_print_layout_led(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.")
    elif "场次" in uploaded_file.name:
        st.header("Screening Times Quick Print")
        part1, part2, date_str = process_schedule_times(uploaded_file)
        if part1 is not None and part2 is not None:
            part1_output = create_print_layout_times(part1, "A", date_str)
            part2_output = create_print_layout_times(part2, "C", date_str)
            col1, col2 = st.columns(2)
            with col1:
                st.subheader("Day Shift (End time <= 17:30)")
                if part1_output:
                    tab1_1, tab1_2 = st.tabs(["PDF Preview", "PNG Preview"])
                    with tab1_1:
                        st.markdown(display_pdf(part1_output['pdf']), unsafe_allow_html=True)
                    with tab1_2:
                        st.image(part1_output['png'])
                else:
                    st.info("No data for the day shift.")
            with col2:
                st.subheader("Night Shift (End time > 17:30)")
                if part2_output:
                    tab2_1, tab2_2 = st.tabs(["PDF Preview", "PNG Preview"])
                    with tab2_1:
                        st.markdown(display_pdf(part2_output['pdf']), unsafe_allow_html=True)
                    with tab2_2:
                        st.image(part2_output['png'])
                else:
                    st.info("No data for the night shift.")