libs.commands.report.stats_report

  1"""
  2libs/commands/report/results_report.py
  3"""
  4
  5import logging
  6import os
  7from datetime import datetime
  8from io import BytesIO
  9from typing import TYPE_CHECKING, Any, Literal
 10
 11import matplotlib.font_manager as fm
 12import matplotlib.pyplot as plt
 13import pandas as pd
 14from reportlab.lib import colors
 15from reportlab.lib.enums import TA_LEFT, TA_RIGHT
 16from reportlab.lib.pagesizes import A4, landscape
 17from reportlab.lib.styles import ParagraphStyle
 18from reportlab.lib.units import mm
 19from reportlab.pdfbase import pdfmetrics
 20from reportlab.pdfbase.ttfonts import TTFont
 21from reportlab.platypus import Image, LongTable, PageBreak, Paragraph, SimpleDocTemplate, Spacer, TableStyle
 22
 23import libs.global_value as g
 24from libs.functions import lookup, message
 25from libs.types import StyleOptions
 26from libs.utils import dbutil, formatter
 27
 28if TYPE_CHECKING:
 29    from integrations.protocols import MessageParserProtocol
 30
 31
 32def get_game_results() -> list[list[str]]:
 33    """
 34    月/年単位のゲーム結果集計
 35
 36    Returns:
 37        list[list[str]]: 集計結果のリスト
 38
 39    """
 40    resultdb = dbutil.connection(g.cfg.setting.database_file)
 41    rows = resultdb.execute(
 42        g.params.query_modification(dbutil.query("REPORT_PERSONAL_DATA")),
 43        g.params.placeholder(),
 44    )
 45
 46    # --- データ収集
 47    results: list[list[str]] = [
 48        [
 49            "",
 50            "ゲーム数",
 51            "通算\nポイント",
 52            "平均\nポイント",
 53            "1位",
 54            "",
 55            "2位",
 56            "",
 57            "3位",
 58            "",
 59            "4位",
 60            "",
 61            "平均\n順位",
 62            "トビ",
 63            "",
 64        ]
 65    ]
 66
 67    for row in rows.fetchall():
 68        if row["ゲーム数"] == 0:
 69            break
 70
 71        results.append(
 72            [
 73                row["集計"],
 74                row["ゲーム数"],
 75                str(row["通算ポイント"]).replace("-", "▲") + "pt",
 76                str(row["平均ポイント"]).replace("-", "▲") + "pt",
 77                row["1位"],
 78                f"{row['1位率']:.2f}%",
 79                row["2位"],
 80                f"{row['2位率']:.2f}%",
 81                row["3位"],
 82                f"{row['3位率']:.2f}%",
 83                row["4位"],
 84                f"{row['4位率']:.2f}%",
 85                f"{row['平均順位']:.2f}",
 86                row["トビ"],
 87                f"{row['トビ率']:.2f}%",
 88            ]
 89        )
 90    logging.debug("return record: %s", len(results))
 91    resultdb.close()
 92
 93    if len(results) == 1:  # ヘッダのみ
 94        return []
 95
 96    return results
 97
 98
 99def get_count_results(game_count: int) -> list[list[str]]:
100    """
101    指定間隔区切りのゲーム結果集計
102
103    Args:
104        game_count (int): 区切るゲーム数
105
106    Returns:
107        list[list[str]]: 集計結果のリスト
108
109    """
110    g.params.interval = game_count
111    resultdb = dbutil.connection(g.cfg.setting.database_file)
112    rows = resultdb.execute(
113        g.params.query_modification(dbutil.query("REPORT_COUNT_DATA")),
114        g.params.placeholder(),
115    )
116
117    # --- データ収集
118    results = [
119        [
120            "開始",
121            "終了",
122            "ゲーム数",
123            "通算\nポイント",
124            "平均\nポイント",
125            "1位",
126            "",
127            "2位",
128            "",
129            "3位",
130            "",
131            "4位",
132            "",
133            "平均\n順位",
134            "トビ",
135            "",
136        ]
137    ]
138
139    for row in rows.fetchall():
140        if row["ゲーム数"] == 0:
141            break
142
143        results.append(
144            [
145                row["開始"],
146                row["終了"],
147                row["ゲーム数"],
148                str(row["通算ポイント"]).replace("-", "▲") + "pt",
149                str(row["平均ポイント"]).replace("-", "▲") + "pt",
150                row["1位"],
151                f"{row['1位率']:.2f}%",
152                row["2位"],
153                f"{row['2位率']:.2f}%",
154                row["3位"],
155                f"{row['3位率']:.2f}%",
156                row["4位"],
157                f"{row['4位率']:.2f}%",
158                f"{row['平均順位']:.2f}",
159                row["トビ"],
160                f"{row['トビ率']:.2f}%",
161            ]
162        )
163    logging.debug("return record: %s", len(results))
164    resultdb.close()
165
166    if len(results) == 1:  # ヘッダのみ
167        return []
168
169    return results
170
171
172def get_count_moving(game_count: int) -> list[dict[str, Any]]:
173    """
174    移動平均を取得する
175
176    Args:
177        game_count (int): 平滑化するゲーム数
178
179    Returns:
180        list[dict[str, Any]]: 集計結果のリスト
181
182    """
183    resultdb = dbutil.connection(g.cfg.setting.database_file)
184    g.params.interval = game_count
185    rows = resultdb.execute(
186        g.params.query_modification(dbutil.query("REPORT_COUNT_MOVING")),
187        g.params.placeholder(),
188    )
189
190    # --- データ収集
191    results = []
192    for row in rows.fetchall():
193        results.append(dict(row))
194
195    logging.debug("return record: %s", len(results))
196    resultdb.close()
197
198    return results
199
200
201def graphing_mean_rank(df: pd.DataFrame, title: str, whole: bool = False) -> BytesIO:
202    """
203    平均順位の折れ線グラフを生成
204
205    Args:
206        df (pd.DataFrame): 描写データ
207        title (str): グラフタイトル
208        whole (bool, optional): 集計種別. Defaults to False.
209            - *True*: 全体集計
210            - *False*: 指定範囲集計
211
212    Returns:
213        BytesIO: 画像データ
214
215    """
216    imgdata = BytesIO()
217
218    if whole:
219        df.plot(
220            kind="line",
221            figsize=(12, 5),
222            fontsize=14,
223        )
224        plt.legend(
225            title="開始 - 終了",
226            ncol=int(len(df.columns) / 5) + 1,
227        )
228    else:
229        df.plot(
230            kind="line",
231            y="rank_avg",
232            x="game_no",
233            legend=False,
234            figsize=(12, 5),
235            fontsize=14,
236        )
237
238    plt.title(title, fontsize=18)
239    plt.grid(axis="y")
240
241    # Y軸設定
242    plt.ylabel("平均順位", fontsize=14)
243    plt.yticks([4.0, 3.5, 3.0, 2.5, 2.0, 1.5, 1.0])
244    for ax in plt.gcf().get_axes():  # 逆向きにする
245        ax.invert_yaxis()
246
247    # X軸設定
248    plt.xlabel("ゲーム数", fontsize=14)
249
250    plt.savefig(imgdata, format="jpg", bbox_inches="tight")
251    return imgdata
252
253
254def graphing_total_points(df: pd.DataFrame, title: str, whole: bool = False) -> BytesIO:
255    """
256    通算ポイント推移の折れ線グラフを生成
257
258    Args:
259        df (pd.DataFrame): 描写データ
260        title (str): グラフタイトル
261        whole (bool, optional): 集計種別. Defaults to False.
262            - *True*: 全体集計 / 移動平均付き
263            - *False*: 指定範囲集計
264    Returns:
265        BytesIO: 画像データ
266
267    """
268    imgdata = BytesIO()
269
270    if whole:
271        df.plot(
272            kind="line",
273            figsize=(12, 8),
274            fontsize=14,
275        )
276        plt.legend(
277            title="通算 （ 開始 - 終了 ）",
278            ncol=int(len(df.columns) / 5) + 1,
279        )
280    else:
281        point_sum = df.plot(
282            kind="line",
283            y="point_sum",
284            label="通算",
285            figsize=(12, 8),
286            fontsize=14,
287        )
288        if len(df) > 50:
289            point_sum = (
290                df["point_sum"]
291                .rolling(40)
292                .mean()
293                .plot(
294                    kind="line",
295                    label="移動平均(40ゲーム)",
296                    ax=point_sum,
297                )
298            )
299        if len(df) > 100:
300            point_sum = (
301                df["point_sum"]
302                .rolling(80)
303                .mean()
304                .plot(
305                    kind="line",
306                    label="移動平均(80ゲーム)",
307                    ax=point_sum,
308                )
309            )
310        plt.legend()
311
312    plt.title(title, fontsize=18)
313    plt.grid(axis="y")
314
315    # Y軸設定
316    plt.ylabel("ポイント", fontsize=14)
317    ylocs, ylabs = plt.yticks()
318    new_ylabs = [ylab.get_text().replace("−", "▲") for ylab in ylabs]
319    plt.yticks(list(ylocs[1:-1]), new_ylabs[1:-1])
320
321    # X軸設定
322    plt.xlabel("ゲーム数", fontsize=14)
323
324    plt.savefig(imgdata, format="jpg", bbox_inches="tight")
325    return imgdata
326
327
328def graphing_rank_distribution(df: pd.DataFrame, title: str) -> BytesIO:
329    """
330    順位分布の棒グラフを生成
331
332    Args:
333        df (pd.DataFrame): 描写データ
334        title (str): グラフタイトル
335
336    Returns:
337        BytesIO: 画像データ
338
339    """
340    imgdata = BytesIO()
341
342    df.plot(
343        kind="bar",
344        stacked=True,
345        figsize=(12, 7),
346        fontsize=14,
347    )
348
349    plt.title(title, fontsize=18)
350    plt.legend(
351        bbox_to_anchor=(0.5, 0),
352        loc="lower center",
353        ncol=4,
354        fontsize=12,
355    )
356
357    # Y軸設定
358    plt.yticks([0, 25, 50, 75, 100])
359    plt.ylabel("（％）", fontsize=14)
360    for ax in plt.gcf().get_axes():  # グリッド線を背後にまわす
361        ax.set_axisbelow(True)
362        plt.grid(axis="y")
363
364    # X軸設定
365    if len(df) > 10:
366        plt.xticks(rotation=30, ha="right")
367    else:
368        plt.xticks(rotation=30)
369
370    plt.savefig(imgdata, format="jpg", bbox_inches="tight")
371    return imgdata
372
373
374def gen_pdf(m: "MessageParserProtocol") -> None:
375    """
376    成績レポートを生成する
377
378    Args:
379        m (MessageParserProtocol): メッセージデータ
380
381    """
382    if g.adapter.conf.plotting_backend == "plotly":
383        m.post.reset()
384        m.set_headline(message.random_reply(m, "not_implemented"), StyleOptions())
385        return
386
387    if not g.params.player_name:  # レポート対象の指定なし
388        m.set_headline(message.random_reply(m, "no_target"), StyleOptions(title="成績レポート"))
389        m.status.result = False
390        return
391
392    # 対象メンバーの記録状況
393    target_info = lookup.member_info(g.params.placeholder())
394    logging.debug(target_info)
395
396    if not target_info["game_count"]:  # 記録なし
397        m.set_headline(message.random_reply(m, "no_hits"), StyleOptions(title="成績レポート"))
398        m.status.result = False
399        return
400
401    # 書式設定
402    font_path = os.path.join(os.path.realpath(os.path.curdir), g.cfg.setting.font_file)
403    pdf_path = g.cfg.setting.work_dir / (f"{g.params.filename}.pdf" if g.params.filename else "results.pdf")
404    pdfmetrics.registerFont(TTFont("ReportFont", font_path))
405
406    doc = SimpleDocTemplate(
407        str(pdf_path),
408        pagesize=landscape(A4),
409        topMargin=10.0 * mm,
410        bottomMargin=10.0 * mm,
411        # leftMargin=1.5 * mm,
412        # rightMargin=1.5 * mm,
413    )
414
415    style: dict[str, Any] = {}
416    style["Title"] = ParagraphStyle(name="Title", fontName="ReportFont", fontSize=24)
417    style["Normal"] = ParagraphStyle(name="Normal", fontName="ReportFont", fontSize=14)
418    style["Left"] = ParagraphStyle(name="Left", fontName="ReportFont", fontSize=14, alignment=TA_LEFT)
419    style["Right"] = ParagraphStyle(name="Right", fontName="ReportFont", fontSize=14, alignment=TA_RIGHT)
420
421    plt.rcdefaults()
422    font_prop = fm.FontProperties(fname=font_path)
423    plt.rcParams["font.family"] = font_prop.get_name()
424    fm.fontManager.addfont(font_path)
425
426    # レポート作成
427    elements: list[Any] = []
428    elements.extend(cover_page(style, target_info))  # 表紙
429    elements.extend(entire_aggregate(style))  # 全期間
430    elements.extend(periodic_aggregation(style))  # 期間集計
431    elements.extend(sectional_aggregate(style, target_info))  # 区間集計
432
433    doc.build(elements)
434    logging.debug("report generation: %s", g.params.player_name)
435
436    m.set_message(pdf_path, StyleOptions(title=f"成績レポート({g.params.player_name})", use_comment=True, header_hidden=True))
437
438
439def cover_page(style: dict[str, Any], target_info: dict[str, Any]) -> list[Any]:
440    """
441    表紙生成
442
443    Args:
444        style (dict[str, Any]): レイアウトスタイル
445        target_info (dict[str, Any]): プレイヤー情報
446
447    Returns:
448        list[Any]: 生成内容
449
450    """
451    elements: list[Any] = []
452
453    first_game = datetime.fromtimestamp(  # 最初のゲーム日時
454        float(target_info["first_game"])
455    )
456    last_game = datetime.fromtimestamp(  # 最後のゲーム日時
457        float(target_info["last_game"])
458    )
459
460    if g.params.anonymous:
461        mapping_dict = formatter.anonymous_mapping([g.params.player_name])
462        target_player = next(iter(mapping_dict.values()))
463    else:
464        target_player = g.params.player_name
465
466    # 表紙
467    elements.append(Spacer(1, 40 * mm))
468    elements.append(Paragraph(f"成績レポート：{target_player}", style["Title"]))
469    elements.append(Spacer(1, 10 * mm))
470    elements.append(
471        Paragraph(
472            f"集計期間：{first_game.strftime('%Y-%m-%d %H:%M')} - {last_game.strftime('%Y-%m-%d %H:%M')}",
473            style["Normal"],
474        )
475    )
476    elements.append(Spacer(1, 100 * mm))
477    elements.append(Paragraph(f"作成日：{datetime.now().strftime('%Y-%m-%d')}", style["Right"]))
478    elements.append(PageBreak())
479
480    return elements
481
482
483def entire_aggregate(style: dict[str, Any]) -> list[Any]:
484    """
485    全期間
486
487    Args:
488        style (dict[str, Any]): レイアウトスタイル
489
490    Returns:
491        list[Any]: 生成内容
492
493    """
494    elements: list[Any] = []
495
496    elements.append(Paragraph("全期間", style["Left"]))
497    elements.append(Spacer(1, 5 * mm))
498    data: list[list[str]] = []
499    g.params.aggregate_unit = "A"
500    tmp_data = get_game_results()
501
502    if not tmp_data:
503        return []
504
505    for _, val in enumerate(tmp_data):  # ゲーム数を除外
506        data.append(val[1:])
507    tt = LongTable(data, repeatRows=1)
508    tt.setStyle(
509        TableStyle(
510            [
511                ("FONT", (0, 0), (-1, -1), "ReportFont", 10),
512                ("GRID", (0, 0), (-1, -1), 0.25, colors.black),
513                ("VALIGN", (0, 0), (-1, -1), "MIDDLE"),
514                ("ALIGN", (0, 0), (-1, -1), "CENTER"),
515                ("SPAN", (3, 0), (4, 0)),
516                ("SPAN", (5, 0), (6, 0)),
517                ("SPAN", (7, 0), (8, 0)),
518                ("SPAN", (9, 0), (10, 0)),
519                ("SPAN", (12, 0), (13, 0)),
520                # ヘッダ行
521                ("BACKGROUND", (0, 0), (-1, 0), colors.navy),
522                ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
523            ]
524        )
525    )
526    elements.append(tt)
527
528    # 順位分布
529    imgdata = BytesIO()
530    gdata = pd.DataFrame(
531        {
532            "順位分布": [
533                float(str(data[1][4]).replace("%", "")),
534                float(str(data[1][6]).replace("%", "")),
535                float(str(data[1][8]).replace("%", "")),
536                float(str(data[1][10]).replace("%", "")),
537            ],
538        },
539        index=["1位率", "2位率", "3位率", "4位率"],
540    )
541    gdata.plot(
542        kind="pie",
543        y="順位分布",
544        labels=None,
545        figsize=(6, 6),
546        fontsize=14,
547        autopct="%.2f%%",
548        wedgeprops={"linewidth": 1, "edgecolor": "white"},
549    )
550    plt.title("順位分布 （ 全期間 ）", fontsize=18)
551    plt.ylabel("")
552    plt.legend(
553        labels=list(gdata.index),
554        bbox_to_anchor=(0.5, -0.1),
555        loc="lower center",
556        ncol=4,
557        fontsize=12,
558    )
559    plt.savefig(imgdata, format="jpg", bbox_inches="tight")
560
561    elements.append(Spacer(1, 5 * mm))
562    elements.append(Image(imgdata, width=600 * 0.5, height=600 * 0.5))
563
564    df = pd.DataFrame(get_count_moving(0))
565    df["playtime"] = pd.to_datetime(df["playtime"])
566
567    # 通算ポイント推移
568    imgdata = graphing_total_points(df, "通算ポイント推移 （ 全期間 ）", False)
569    elements.append(Image(imgdata, width=1200 * 0.5, height=800 * 0.5))
570
571    # 平均順位
572    imgdata = graphing_mean_rank(df, "平均順位推移 （ 全期間 ）", False)
573    elements.append(Image(imgdata, width=1200 * 0.5, height=500 * 0.5))
574
575    elements.append(PageBreak())
576
577    return elements
578
579
580def periodic_aggregation(style: dict[str, Any]) -> list[Any]:
581    """
582    期間集計
583
584    Args:
585        style (dict[str, Any]): レイアウトスタイル
586
587    Returns:
588        list[Any]: 生成内容
589
590    """
591    elements: list[Any] = []
592
593    pattern: list[tuple[str, str, Literal["A", "M", "Y"]]] = [
594        # 表タイトル, グラフタイトル, フラグ
595        ("月別集計", "順位分布（月別）", "M"),
596        ("年別集計", "順位分布（年別）", "Y"),
597    ]
598
599    for table_title, graph_title, flag in pattern:
600        elements.append(Paragraph(table_title, style["Left"]))
601        elements.append(Spacer(1, 5 * mm))
602
603        data: list[list[str]] = []
604        g.params.aggregate_unit = flag
605        tmp_data = get_game_results()
606
607        if not tmp_data:
608            return []
609
610        for _, val in enumerate(tmp_data):  # 日時を除外
611            data.append(val[:15])
612
613        tt = LongTable(data, repeatRows=1)
614        ts = TableStyle(
615            [
616                ("FONT", (0, 0), (-1, -1), "ReportFont", 10),
617                ("GRID", (0, 0), (-1, -1), 0.25, colors.black),
618                ("VALIGN", (0, 0), (-1, -1), "MIDDLE"),
619                ("ALIGN", (0, 0), (-1, -1), "CENTER"),
620                ("SPAN", (4, 0), (5, 0)),
621                ("SPAN", (6, 0), (7, 0)),
622                ("SPAN", (8, 0), (9, 0)),
623                ("SPAN", (10, 0), (11, 0)),
624                ("SPAN", (13, 0), (14, 0)),
625                # ヘッダ行
626                ("BACKGROUND", (0, 0), (-1, 0), colors.navy),
627                ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
628            ]
629        )
630
631        if len(data) > 4:
632            for i in range(len(data) - 2):
633                if i % 2 == 0:
634                    ts.add("BACKGROUND", (0, i + 2), (-1, i + 2), colors.lightgrey)
635        tt.setStyle(ts)
636        elements.append(tt)
637        elements.append(Spacer(1, 10 * mm))
638
639        # 順位分布
640        df = pd.DataFrame(
641            {
642                "1位率": [float(str(data[x + 1][5]).replace("%", "")) for x in range(len(data) - 1)],
643                "2位率": [float(str(data[x + 1][7]).replace("%", "")) for x in range(len(data) - 1)],
644                "3位率": [float(str(data[x + 1][9]).replace("%", "")) for x in range(len(data) - 1)],
645                "4位率": [float(str(data[x + 1][11]).replace("%", "")) for x in range(len(data) - 1)],
646            },
647            index=[data[x + 1][0] for x in range(len(data) - 1)],
648        )
649
650        imgdata = graphing_rank_distribution(df, graph_title)
651        elements.append(Spacer(1, 5 * mm))
652        elements.append(Image(imgdata, width=1200 * 0.5, height=700 * 0.5))
653
654        elements.append(PageBreak())
655
656    return elements
657
658
659def sectional_aggregate(style: dict[str, Any], target_info: dict[str, Any]) -> list[Any]:
660    """
661    区間集計
662
663    Args:
664        style (dict[str, Any]): レイアウトスタイル
665        target_info (dict[str, Any]): プレイヤー情報
666
667    Returns:
668        list[Any]: 生成内容
669
670    """
671    elements: list[Any] = []
672
673    pattern: list[tuple[int, int, str]] = [
674        # 区切り回数, 閾値, タイトル
675        (80, 100, "短期"),
676        (200, 240, "中期"),
677        (400, 500, "長期"),
678    ]
679
680    for count, threshold, title in pattern:
681        if target_info["game_count"] > threshold:
682            # テーブル
683            elements.append(Paragraph(f"区間集計 （ {title} ）", style["Left"]))
684            elements.append(Spacer(1, 5 * mm))
685            data = get_count_results(count)
686
687            if not data:
688                return []
689
690            tt = LongTable(data, repeatRows=1)
691            ts = TableStyle(
692                [
693                    ("FONT", (0, 0), (-1, -1), "ReportFont", 10),
694                    ("GRID", (0, 0), (-1, -1), 0.25, colors.black),
695                    ("VALIGN", (0, 0), (-1, -1), "MIDDLE"),
696                    ("ALIGN", (0, 0), (-1, -1), "CENTER"),
697                    ("SPAN", (5, 0), (6, 0)),
698                    ("SPAN", (7, 0), (8, 0)),
699                    ("SPAN", (9, 0), (10, 0)),
700                    ("SPAN", (11, 0), (12, 0)),
701                    ("SPAN", (14, 0), (15, 0)),
702                    # ヘッダ行
703                    ("BACKGROUND", (0, 0), (-1, 0), colors.navy),
704                    ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
705                ]
706            )
707            if len(data) > 4:
708                for i in range(len(data) - 2):
709                    if i % 2 == 0:
710                        ts.add("BACKGROUND", (0, i + 2), (-1, i + 2), colors.lightgrey)
711            tt.setStyle(ts)
712            elements.append(tt)
713
714            # 順位分布
715            df = pd.DataFrame(
716                {
717                    "1位率": [float(str(data[x + 1][6]).replace("%", "")) for x in range(len(data) - 1)],
718                    "2位率": [float(str(data[x + 1][8]).replace("%", "")) for x in range(len(data) - 1)],
719                    "3位率": [float(str(data[x + 1][10]).replace("%", "")) for x in range(len(data) - 1)],
720                    "4位率": [float(str(data[x + 1][12]).replace("%", "")) for x in range(len(data) - 1)],
721                },
722                index=[f"{str(data[x + 1][0])} - {str(data[x + 1][1])}" for x in range(len(data) - 1)],
723            )
724
725            imgdata = graphing_rank_distribution(df, f"順位分布 （ 区間 {title} ）")
726            elements.append(Spacer(1, 5 * mm))
727            elements.append(Image(imgdata, width=1200 * 0.5, height=800 * 0.5))
728
729            # 通算ポイント推移
730            tmp_df = pd.DataFrame(get_count_moving(count))
731            df = pd.DataFrame()
732            for i in sorted(tmp_df["interval"].unique().tolist()):
733                list_data = tmp_df[tmp_df.interval == i]["point_sum"].to_list()
734                game_count = tmp_df[tmp_df.interval == i]["total_count"].to_list()
735                df[f"{min(game_count)} - {max(game_count)}"] = [None] * (count - len(list_data)) + list_data
736
737            imgdata = graphing_total_points(df, f"通算ポイント推移（区間 {title}）", True)
738            elements.append(Image(imgdata, width=1200 * 0.5, height=800 * 0.5))
739
740            # 平均順位
741            df = pd.DataFrame()
742            for i in sorted(tmp_df["interval"].unique().tolist()):
743                list_data = tmp_df[tmp_df.interval == i]["rank_avg"].to_list()
744                game_count = tmp_df[tmp_df.interval == i]["total_count"].to_list()
745                df[f"{min(game_count)} - {max(game_count)}"] = [None] * (count - len(list_data)) + list_data
746
747            imgdata = graphing_mean_rank(df, f"平均順位推移（区間 {title}）", True)
748            elements.append(Image(imgdata, width=1200 * 0.5, height=500 * 0.5))
749
750            elements.append(PageBreak())
751
752    return elements