libs.utils.converter

  1"""
  2libs/utils/converter.py
  3"""
  4
  5import textwrap
  6from typing import TYPE_CHECKING, Any, Optional, Union
  7
  8import pandas as pd
  9from table2ascii import Alignment, PresetStyle, table2ascii
 10from tabulate import tabulate
 11
 12import libs.global_value as g
 13from libs.types import StyleOptions
 14from libs.utils import formatter, textutil
 15
 16if TYPE_CHECKING:
 17    from pathlib import Path
 18
 19    from libs.types import MessageType
 20
 21
 22def save_output(
 23    df: pd.DataFrame,
 24    options: StyleOptions,
 25    headline: Optional[tuple["MessageType", StyleOptions]] = None,
 26    suffix: Optional[str] = None,
 27) -> Union["Path", None]:
 28    """
 29    指定されたフォーマットでdfを保存する
 30
 31    Args:
 32        df (pd.DataFrame): 保存対象データ
 33        options (StyleOptions): 詳細オプション
 34        headline (tuple[MessageType, StyleOptions], optional): ヘッダコメント. Defaults to None.
 35        suffix (str, optional): 保存ファイル名に追加する文字列. Defaults to None.
 36
 37    Returns:
 38        Path: 保存したファイルパス
 39        None: ファイル出力なし
 40
 41    """
 42    # カラムリネーム
 43    options.rename_type = StyleOptions.RenameType.NORMAL
 44    df = formatter.df_rename(df, options)
 45    if options.transpose:
 46        df = df.T
 47
 48    match options.format_type:
 49        case "default":
 50            return None
 51        case "csv":
 52            data = df.to_csv(index=options.show_index)
 53        case "txt":
 54            data = df.to_markdown(
 55                index=options.show_index,
 56                tablefmt="outline",
 57                floatfmt=formatter.floatfmt_adjust(df, index=options.show_index),
 58                colalign=formatter.column_alignment(df, index=options.show_index),
 59                headersalign=formatter.column_alignment(df, True),
 60            ).replace(" ▲", "▲")
 61
 62    # 保存
 63    save_file = textutil.save_file_path(options.filename, True)
 64    if suffix and g.params.filename:
 65        save_file = save_file.with_name(f"{save_file.stem}_{suffix}{save_file.suffix}")
 66
 67    with open(save_file, "w", encoding="utf-8") as writefile:
 68        # ヘッダコメント書き込み
 69        if headline:
 70            headline_data, headline_option = headline
 71            if options.key_title:
 72                writefile.writelines(f"# 【{headline_option.title}】\n")
 73            if isinstance(headline_data, str):
 74                for line in headline_data.splitlines():
 75                    writefile.writelines(f"# {line}\n")
 76                writefile.writelines("\n")
 77
 78        # 本文書き込み
 79        writefile.writelines(data)
 80
 81    return save_file
 82
 83
 84def df_to_text_table(df: pd.DataFrame, options: StyleOptions, step: int = 40) -> dict[str, str]:
 85    """
 86    DataFrameからテキストテーブルの生成
 87
 88    Args:
 89        df (pd.DataFrame): 対象データ
 90        options (StyleOptions): 表示フラグ
 91        step (int, optional): 分割行. Defaults to 40.
 92
 93    Returns:
 94        dict[str, str]: 生成テーブル
 95
 96    """
 97    df = formatter.df_rename(df, options)
 98
 99    # ヘッダ/位置
100    header: list[str] = []
101    alignments: list[Alignment] = []
102    if options.show_index:
103        df.reset_index(inplace=True, drop=True)
104        df.index += 1
105        header.append("")
106    for col in df.columns:
107        header.append(col)
108        match col:
109            case "名前" | "プレイヤー名" | "チーム" | "チーム名":
110                alignments.append(Alignment.LEFT)
111            case "順位分布":
112                alignments.append(Alignment.LEFT)
113            case _:
114                alignments.append(Alignment.RIGHT)
115
116    # 表データ
117    body: list[list[Any]] = []
118    data: list[str] = []
119    for row in df.to_dict(orient="records"):
120        data.clear()
121        for k, v in row.items():
122            match k:
123                case "通算" | "平均" | "平均素点":
124                    data.append(f" {v:+.1f}".replace(" -", "▲"))
125                case "平順" | "平均順位":
126                    data.append(f"{v:.2f}")
127                case "レート":
128                    data.append(f"{v:.1f}")
129                case "順位偏差" | "得点偏差":
130                    data.append(f"{v:.0f}")
131                case _:
132                    data.append(str(v).replace("nan", "*****"))
133            if options.show_index:
134                data.insert(0, "")
135        body.append(data.copy())
136
137    # 表生成/分割
138    my_style = PresetStyle.plain
139    my_style.heading_row_sep = "-"
140    my_style.heading_row_right_tee = ""
141    my_style.heading_row_left_tee = ""
142
143    table_data: dict[str, str] = {}
144    for idx, table_body in enumerate(textutil.split_balanced(body, step)):
145        output = table2ascii(
146            header=header,
147            body=table_body,
148            style=my_style,
149            cell_padding=0,
150            first_col_heading=options.show_index,
151            alignments=alignments,
152        )
153        table_data.update({f"{idx}": output})
154
155    return table_data
156
157
158def df_to_text_table2(df: pd.DataFrame, options: StyleOptions, limit: int = 2000) -> dict[str, str]:
159    """
160    DataFrameからテキストテーブルの生成(縦横変換)
161
162    Args:
163        df (pd.DataFrame): 対象データ
164        options (StyleOptions): 表示フラグ
165        limit (int, optional): 分割文字数. Defaults to 2000.
166
167    Returns:
168        dict: 生成テーブル
169
170    """
171    df = formatter.df_rename(df, options)
172
173    # 表生成/分割
174    my_style = PresetStyle.plain
175    my_style.heading_row_sep = "-"
176    my_style.heading_row_right_tee = ""
177    my_style.heading_row_left_tee = ""
178    my_style.heading_col_sep = "： "
179
180    table_data: dict[str, str] = {}
181    start_block: int = 0
182
183    safe_output: str = ""
184    output: str = ""
185
186    for cur_block in range(len(df.columns) + 1):
187        chk_df = df.iloc[:, start_block:cur_block]
188
189        # ヘッダ
190        header: list[str] = chk_df.columns.to_list()
191        if options.show_index:
192            header.insert(0, "")
193
194        # ボディ
195        body: list[list[Any]] = []
196        data: list[Any] = []
197        for idx, item in chk_df.iterrows():
198            data.clear()
199            data.append(idx)
200            data.extend(item.to_list())
201            body.append(data.copy())
202
203        output = table2ascii(
204            header=header,
205            body=body,
206            style=my_style,
207            cell_padding=0,
208            alignments=[Alignment.RIGHT] * len(header),
209            first_col_heading=options.show_index,
210        )
211
212        # 文字数チェック
213        if len(output) < limit:
214            safe_output = output
215        else:
216            table_data.update({f"{cur_block}": safe_output})
217            start_block = cur_block - 1
218    # 最終ブロック
219    if cur_block <= len(df.columns):
220        table_data.update({f"{cur_block}": output})
221
222    return table_data
223
224
225def df_to_results_details(df: pd.DataFrame, options: StyleOptions, limit: int = 2000) -> dict[str, str]:
226    """
227    戦績(詳細)データをテキスト変換
228
229    Args:
230        df (pd.DataFrame): 対象データ
231        options (StyleOptions): 表示フラグ
232        limit (int, optional): 分割文字数. Defaults to 2000.
233
234    Returns:
235        dict[str, str]: 整形テキスト
236
237    """
238    df = formatter.df_rename(df, options)
239
240    data_list: list[str] = []
241    game_results: dict[str, dict[str, Any]] = {}
242
243    for x in df.to_dict(orient="index").values():
244        game_results[x["日時"]] = {"備考": x["備考"]}
245        for seat in ("東家", "南家", "西家", "北家"):
246            game_results[x["日時"]].update(
247                {
248                    seat: [
249                        x[f"{seat} 名前"],
250                        f"{(x[f'{seat} 素点'])}点".replace("-", "▲"),
251                        f"{(x[f'{seat} 順位'])}位",
252                        f"({float(x[f'{seat} ポイント']):+.1f}pt)".replace("-", "▲"),
253                        x[f"{seat} メモ"],
254                    ]
255                }
256            )
257
258    for k, v in game_results.items():
259        body = [["　東家："] + v["東家"], ["　南家："] + v["南家"], ["　西家："] + v["西家"], ["　北家："] + v["北家"]]
260        output = table2ascii(
261            body=body,
262            style=PresetStyle.plain,
263            cell_padding=0,
264            first_col_heading=True,
265            alignments=[Alignment.LEFT, Alignment.LEFT, Alignment.RIGHT, Alignment.RIGHT, Alignment.RIGHT, Alignment.LEFT],
266        )
267        data_list.append(f"{k.replace('-', '/')} {v['備考']}\n" + output + "\n")
268
269    return {str(idx): x for idx, x in enumerate(formatter.group_strings(data_list, limit))}
270
271
272def df_to_results_simple(df: pd.DataFrame, options: StyleOptions, limit: int = 2000) -> dict[str, str]:
273    """
274    戦績(簡易)データをテキスト変換
275
276    Args:
277        df (pd.DataFrame): 対象データ
278        options (StyleOptions): 表示フラグ
279        limit (int, optional): 分割文字数. Defaults to 2000.
280
281    Returns:
282        dict[str, str]: 整形テキスト
283
284    """
285    df = formatter.df_rename(df, options)
286
287    data_list: list[str] = []
288    for x in df.to_dict(orient="index").values():
289        vs_guest = ""
290        if x["備考"] != "":
291            vs_guest = f"({g.cfg.setting.guest_mark}) "
292
293        ret = f"　{vs_guest}{str(x['日時']).replace('-', '/')}  "
294        ret += f"{x['座席']}\t{x['順位']}位\t{x['素点']:8d}点\t{x['獲得ポイント']:7.1f}pt\t{x['メモ']}".replace("-", "▲")
295        data_list.append(ret)
296
297    return {str(idx): x for idx, x in enumerate(formatter.group_strings(data_list, limit))}
298
299
300def df_to_ranking(df: pd.DataFrame, title: str, step: int = 40) -> dict[str, str]:
301    """
302    DataFrameからランキングテーブルを生成
303
304    Args:
305        df (pd.DataFrame): 対象データ
306        title (str): 種別
307        step (int, optional): 分割行. Defaults to 40.
308
309    Returns:
310        dict[str, str]: 整形テキスト
311
312    """
313    # 表示内容
314    body: list[list[Any]] = []
315    alignments: list[Alignment] = []
316    match title:
317        case "ゲーム参加率":
318            alignments = [Alignment.RIGHT, Alignment.LEFT, Alignment.RIGHT, Alignment.LEFT]
319            for x in df.itertuples():
320                body.append(
321                    [
322                        f"{x.rank}:",
323                        x.name,
324                        x.participation_rate,
325                        f"({x.count}/{x.total_count}G)",
326                    ]
327                )
328        case "通算ポイント":
329            alignments = [Alignment.RIGHT, Alignment.LEFT, Alignment.RIGHT, Alignment.LEFT]
330            for x in df.itertuples():
331                body.append(
332                    [
333                        f"{x.rank}:",
334                        x.name,
335                        x.total_point,
336                        f"({x.count}G)",
337                    ]
338                )
339        case "平均ポイント":
340            alignments = [Alignment.RIGHT, Alignment.LEFT, Alignment.RIGHT, Alignment.LEFT]
341            for x in df.itertuples():
342                body.append(
343                    [
344                        f"{x.rank}:",
345                        x.name,
346                        x.avg_point,
347                        f"({x.total_point}/{x.count}G)",
348                    ]
349                )
350        case "平均収支":
351            alignments = [Alignment.RIGHT, Alignment.LEFT, Alignment.RIGHT, Alignment.LEFT]
352            for x in df.itertuples():
353                body.append(
354                    [
355                        f"{x.rank}:",
356                        x.name,
357                        x.avg_balance,
358                        f"({x.rpoint_avg}/{x.count}G)",
359                    ]
360                )
361        case "トップ率":
362            alignments = [Alignment.RIGHT, Alignment.LEFT, Alignment.RIGHT, Alignment.LEFT]
363            for x in df.itertuples():
364                body.append(
365                    [
366                        f"{x.rank}:",
367                        x.name,
368                        x.rank1_rate,
369                        f"({x.rank1}/{x.count}G)",
370                    ]
371                )
372        case "連対率":
373            alignments = [Alignment.RIGHT, Alignment.LEFT, Alignment.RIGHT, Alignment.LEFT]
374            for x in df.itertuples():
375                body.append(
376                    [
377                        f"{x.rank}:",
378                        x.name,
379                        x.top2_rate,
380                        f"({x.top2}/{x.count}G)",
381                    ]
382                )
383        case "ラス回避率":
384            alignments = [Alignment.RIGHT, Alignment.LEFT, Alignment.RIGHT, Alignment.LEFT]
385            for x in df.itertuples():
386                body.append(
387                    [
388                        f"{x.rank}:",
389                        x.name,
390                        x.top3_rate,
391                        f"({x.top3}/{x.count}G)",
392                    ]
393                )
394        case "トビ率":
395            alignments = [Alignment.RIGHT, Alignment.LEFT, Alignment.RIGHT, Alignment.LEFT]
396            for x in df.itertuples():
397                body.append(
398                    [
399                        f"{x.rank}:",
400                        x.name,
401                        x.flying_rate,
402                        f"({x.flying}/{x.count}G)",
403                    ]
404                )
405        case "平均順位":
406            alignments = [Alignment.RIGHT, Alignment.LEFT, Alignment.RIGHT, Alignment.LEFT]
407            for x in df.itertuples():
408                body.append(
409                    [
410                        f"{x.rank}:",
411                        x.name,
412                        f"{x.rank_avg}",
413                        f"({x.rank_distr}={x.count})".replace("-", "+"),
414                    ]
415                )
416        case "役満和了率":
417            alignments = [Alignment.RIGHT, Alignment.LEFT, Alignment.RIGHT, Alignment.LEFT]
418            for x in df.itertuples():
419                body.append(
420                    [
421                        f"{x.rank}:",
422                        x.name,
423                        x.yakuman_rate,
424                        f"({x.yakuman}/{x.count}G)",
425                    ]
426                )
427        case "最大素点":
428            alignments = [Alignment.RIGHT, Alignment.LEFT, Alignment.RIGHT, Alignment.LEFT]
429            for x in df.itertuples():
430                body.append(
431                    [
432                        f"{x.rank}:",
433                        x.name,
434                        x.rpoint_max,
435                        f"({x.point_max})",
436                    ]
437                )
438        case "連続トップ":
439            alignments = [Alignment.RIGHT, Alignment.LEFT, Alignment.LEFT]
440            for x in df.itertuples():
441                body.append(
442                    [
443                        f"{x.rank}:",
444                        x.name,
445                        f"{x.top1_max:>2d}連続 / {x.count}G",
446                    ]
447                )
448        case "連続連対":
449            alignments = [Alignment.RIGHT, Alignment.LEFT, Alignment.LEFT]
450            for x in df.itertuples():
451                body.append(
452                    [
453                        f"{x.rank}:",
454                        x.name,
455                        f"{x.top2_max:>2d}連続 / {x.count}G",
456                    ]
457                )
458        case "連続ラス回避":
459            alignments = [Alignment.RIGHT, Alignment.LEFT, Alignment.LEFT]
460            for x in df.itertuples():
461                body.append(
462                    [
463                        f"{x.rank}:",
464                        x.name,
465                        f"{x.top3_max:>2d}連続 / {x.count}G",
466                    ]
467                )
468        case _:
469            return {}
470
471    # 整形/分割
472    ret: dict[str, str] = {}
473    data: list[list[Any]] = []
474    if step:
475        data = textutil.split_balanced(body, step)
476        last_block = len(data)
477    else:
478        last_block = 1
479
480    if last_block == 1:
481        output = table2ascii(
482            body=body,
483            style=PresetStyle.plain,
484            cell_padding=0,
485            first_col_heading=True,
486            alignments=alignments,
487        )
488        ret.update({title: output})
489    else:
490        count = 0
491        for work_body in data:
492            count += 1
493            output = table2ascii(
494                body=work_body,
495                style=PresetStyle.plain,
496                cell_padding=0,
497                first_col_heading=True,
498                alignments=alignments,
499            )
500            ret.update({f"{title} ({count}/{last_block})": output})
501
502    return ret
503
504
505def df_to_remarks(df: pd.DataFrame, options: StyleOptions) -> dict[str, str]:
506    """
507    DataFrameからメモテーブルを生成
508
509    Args:
510        df (pd.DataFrame): 対象データ
511        options (StyleOptions): 表示フラグ
512
513    Returns:
514        dict[str, str]: 整形テキスト
515
516    """
517    df = formatter.df_rename(df, options)
518
519    key_name = "名前" if g.params.individual else "チーム"
520    for col in df.columns:
521        match col:
522            case "日時":
523                df["日時"] = df["日時"].map(lambda x: str(x).replace("-", "/"))
524            case "ポイント":
525                df["ポイント"] = df["ポイント"].map(lambda x: f"{x}pt".replace("-", "▲"))
526
527    if "日時" in df.columns:
528        if "ポイント" in df.columns:
529            df["表示"] = df.apply(lambda x: f"{x['日時']} {x['ポイント']} {x['内容']} （{x[key_name]}）", axis=1)
530        elif "和了役" in df.columns:
531            df["表示"] = df.apply(lambda x: f"{x['日時']} {x['和了役']} （{x[key_name]}）", axis=1)
532        else:
533            df["表示"] = df.apply(lambda x: f"{x['日時']} {x['内容']} （{x[key_name]}）", axis=1)
534    elif "回数" in df.columns:
535        if "ポイント" in df.columns:
536            df["表示"] = df.apply(lambda x: f"{x['内容']}： {x['回数']} 回 ({x['ポイント合計']:.1f}pt)".replace("-", "▲"), axis=1)
537        elif "和了役" in df.columns:
538            df["表示"] = df.apply(lambda x: f"{x['和了役']}： {x['回数']} 回", axis=1)
539        else:
540            df["表示"] = df.apply(lambda x: f"{x['内容']}： {x['回数']} 回", axis=1)
541
542    tbl = tabulate(df.filter(items=["表示"]).values, showindex=False).splitlines()[1:-1]
543    return {"0": textwrap.indent("\n".join(tbl), "\t" * options.indent)}
544
545
546def df_to_seat_data(df: pd.DataFrame, options: StyleOptions) -> dict[str, str]:
547    """
548    座席データ生成
549
550    Args:
551        df (pd.DataFrame): 対象データ
552        options (StyleOptions): 表示フラグ
553
554    Returns:
555        dict[str, str]: 整形テキスト
556
557    """
558    df = formatter.df_rename(df, options)
559
560    # 表示加工
561    df["順位分布(平均順位)"] = df.apply(lambda x: f"{x['順位分布']} ({x['平均順位']})", axis=1)
562    df.drop(columns=["順位分布", "平均順位"], inplace=True)
563    df["席"] = df.apply(lambda x: f"{x['席']}：", axis=1)
564    if "トビ" in df.columns:
565        df["トビ"] = df.apply(lambda x: f"/ {x['トビ']:3d}", axis=1)
566    if "役満和了" in df.columns:
567        df["役満和了"] = df.apply(lambda x: f"/ {x['役満和了']:3d}", axis=1)
568
569    #
570    df = df.filter(items=["席", "順位分布(平均順位)", "トビ", "役満和了"]).rename(columns={"席": "# 席：", "トビ": "/ トビ", "役満和了": "/ 役満 #"})
571
572    tbl = df.to_markdown(tablefmt="tsv", index=False).replace("0.00", "-.--").replace(" \t", "")
573    return {"0": textwrap.indent(tbl, "\t" * options.indent)}