update delay report

lib/pages.py

@@ -53,7 +53,7 @@ class TranslatorPage:
             print("click button to set translation off")
 
 
-    def get_current_node_text(self, duration=0, interval=0.1)-> List[WebItem]:
+    def get_current_node_text(self, duration=0, interval=0.05)-> List[WebItem]:
         """在一定时间内持续读取页面最新的 node的内容"""
         print(f"capture page latest content for duration: {duration}s")
         translate_items = []

lib/report.py

@@ -1,27 +1,10 @@
+from datetime import datetime, timedelta
 from typing import List
 from dataclasses import dataclass, astuple
 
 from tabulate import tabulate
 from lib.log_parser import LogTag, LogItem, WebItem
-from lib.utils import save_csv, run_textdistance, highlight_diff
-
-@dataclass
-class Row:
-    audio_end_tsp:str = ""
-    audio_length:str =""
-    tsb_end_tsp:str =""
-    tsb_opt:str =""
-    tsb_cost:str =""
-    tsl_ipt:str =""
-    tsl_end_tsp:str =""
-    tsl_opt:str =""
-    tsl_cost:str =""
-    web_tsp:str =""
-    web_src:str =""
-    web_dst:str =""
-    def __repr__(self):
-        return f"Row(audio_length={self.audio_length}, tsb_opt={self.tsb_opt})"
-
+from lib.utils import save_csv, run_textdistance, highlight_diff, time_to_float
 
 class LogReport:
     """用于处理 log文件"""
@@ -83,6 +66,45 @@ class LogReport:
         rows = [[row[i] for i in header_mapping.values() if i < len(row)] for row in rows]
         save_csv(csv_path, header, rows)
 
+@dataclass
+class DelaySummary:
+    audio_name:str = ""
+    trans_type: str = ""
+    audio_length:str = ""
+    load_start: datetime =None
+    load_end: datetime=None
+    load: float = 0
+    avg_audio_len: float = 0
+    total_tsb: float = 0
+    avg_tsb_per_second: float = 0
+    total_tsl: float = 0
+    avg_tsl_per_second: float = 0
+    total_web: float = 0
+    avg_web_per_second: float = 0
+    avg_web_freq: float = 0
+
+@dataclass
+class DelayDetailRow:
+    audio_end_tsp:datetime = ""
+    audio_length:float =0
+    tsb_end_tsp:datetime =""
+    tsb_opt:str =""
+    tsb_cost:float = 0
+    tsb_cost_per_second: float = 0
+    tsl_ipt:str =""
+    tsl_end_tsp:datetime =""
+    tsl_opt:str =""
+    tsl_cost:float =0
+    tsl_cost_per_second: float = 0
+    web_tsp:datetime =""
+    web_src:str =""
+    web_dst:str =""
+    web_delay: float = 0
+    web_delay_per_second: float = 0
+    web_freq: float = 0
+    def __repr__(self):
+        return f"Row(audio_length={self.audio_length}, tsb_opt={self.tsb_opt})"
+
 @dataclass
 class DelayItem:
     """存储delay 报告中每一个 case的结果"""
@@ -93,29 +115,35 @@ class DelayItem:
     log_items: List[LogItem] = None
 
     def to_rows(self):
-        """将 log和 web的结果合并成 csv行的形式
+        """将 log和 web的结果合并, 返回 DelaySummary和 DelayDetail的列表
         返回 row_0包含音频信息和 load 时间
         rows 是每次推理的详细信息"""
         print(f"length of log_items: {len(self.log_items)}")
         web_items_dict = {i.src_text + i.dst_text: i for i in self.web_items}
 
-        row_0 = [self.translation_type, self.audio, self.audio_length]
-        rows = []
-        current_row = Row()
+        summary = DelaySummary(audio_name=self.audio,trans_type=self.translation_type,
+                               audio_length=self.audio_length)
+        detail_rows = []
+        current_row = DelayDetailRow()
         for i in self.log_items:
-            if i.tag in [LogTag.load_start, LogTag.load_end]:
-                row_0 += [i.tag.name, i.timestamp]
+            if i.tag == LogTag.load_start:
+                summary.load_start = i.timestamp
+            elif i.tag == LogTag.load_end:
+                summary.load_end = i.timestamp
+                summary.load = (summary.load_end-summary.load_start).total_seconds()
             elif i.tag == LogTag.audio_end:
+                if current_row.audio_length > 0:
+                    detail_rows.append(current_row)
                 # 每次到 audio_end就是新的一行
-                rows.append(current_row)
-                current_row = Row()
+                current_row = DelayDetailRow()
                 current_row.audio_end_tsp = i.timestamp
-                current_row.audio_length = i.content.replace(" s", "")
+                current_row.audio_length = time_to_float(i.content)
             elif i.tag == LogTag.transcribe_end:
                 current_row.tsb_end_tsp = i.timestamp
                 current_row.tsb_opt = i.content
             elif i.tag == LogTag.transcribe_cost:
-                current_row.tsb_cost = i.content.replace(" s", "")
+                current_row.tsb_cost = time_to_float(i.content)
+                current_row.tsb_cost_per_second = current_row.tsb_cost/current_row.audio_length
             elif i.tag == LogTag.translate_start:
                 current_row.tsl_ipt = i.content
             elif i.tag in [LogTag.translate_end, LogTag.translate_large_end]:
@@ -126,52 +154,79 @@ class DelayItem:
                     current_row.web_tsp = web_item.timestamp
                     current_row.web_src = web_item.src_text
                     current_row.web_dst = web_item.dst_text
+                    current_row.web_delay = (current_row.web_tsp - current_row.audio_end_tsp).total_seconds()
+                    current_row.web_delay_per_second = current_row.web_delay / current_row.audio_length
                     # 删除 dict已匹配过的内容，避免多次匹配
                     web_items_dict.pop(current_row.tsb_opt+current_row.tsl_opt)
+                    if len(detail_rows)>=1 and detail_rows[-1].web_tsp:
+                        current_row.web_freq = (current_row.web_tsp - detail_rows[-1].web_tsp).total_seconds()
+
             elif i.tag in [LogTag.translate_cost, LogTag.translate_large_cost]:
-                current_row.tsl_cost = i.content.replace(" s", "")
-        # print("rows value in DelayItem:",rows)
+                current_row.tsl_cost = time_to_float(i.content)
+                current_row.tsl_cost_per_second = current_row.tsl_cost/current_row.audio_length
+        summary = self.get_summary(summary, detail_rows)
+        return summary, detail_rows # [astuple(i) for i in rows]
+    def get_summary(self,summary: DelaySummary, detail_rows):
+        audio_len = []
+        total_tsb = []
+        avg_tsb_per_second = []
+        total_tsl = []
+        avg_tsl_per_second = []
+        total_web = []
+        avg_web_per_second = []
+        web_freq = []
+        for row in detail_rows:
+            if row.audio_length:
+                audio_len.append(row.audio_length)
+            if row.tsb_cost:
+                total_tsb.append(row.tsb_cost)
+            if row.tsb_cost_per_second:
+                avg_tsb_per_second.append(row.tsb_cost_per_second)
+            if row.tsl_cost:
+                total_tsl.append(row.tsl_cost)
+            if row.tsl_cost_per_second:
+                avg_tsl_per_second.append(row.tsl_cost_per_second)
+            if row.web_delay:
+                total_web.append(row.web_delay)
+            if row.web_delay_per_second:
+                avg_web_per_second.append(row.web_delay_per_second)
+            if row.web_freq:
+                web_freq.append(row.web_freq)
+
+        summary.avg_audio_len = sum(audio_len) / len(audio_len)
+        summary.total_tsb = sum(total_tsb)
+        summary.avg_tsb_per_second = sum(avg_tsb_per_second) / len(avg_tsb_per_second)
+        summary.total_tsl = sum(total_tsl)
+        summary.avg_tsl_per_second = sum(avg_tsl_per_second) / len(avg_tsl_per_second)
+        summary.total_web = sum(total_web)
+        summary.avg_web_per_second = sum(avg_web_per_second) / len(avg_web_per_second)
+        summary.avg_web_freq = sum(web_freq) /len(web_freq)
+        return summary
 
-        return row_0, rows # [astuple(i) for i in rows]
 
 class DelayReport:
     """存储delay 报告中所有 case的结果"""
     start_line = 0
     items: List[DelayItem] = []
-    # summary_items = {
-    #     "translation_type": "",
-    #     "audio length": "",
-    #     "load_model": "",
-    #     "total_transcribe": "",
-    #     "average_transcribe": "",
-    #     "total_translate": "",
-    #     "average_translate": "",
-    #     "asr accuracy": "",
-    #     "llm translation score": "",
-    #     "delay": "",
-    # }
     def print_summary(self, data):
-        header = ["audio", "load", "total audio len","total tsb","total tsl"]
-        print(tabulate(data, header))
+        print(tabulate(data))
 
     def to_csv(self, csv_path):
-        all_rows = []
-        summaries = []
+        summaries = [["audio_name", "translation", "audio_length",
+                      "load_start", "load_end", "load", "avg_audio_len",
+                      "total_tsb", "avg_tsb_per_sec", "total_tsl", "avg_tsl_per_sec",
+                      "total_web", "avg_web_per_sec", "avg_web_freq"]]
+        details = [["audio_end_tsp", "audio_length",
+                    "tsb_end_tsp", "tsp_opt", "tsb_cost", "tsb_cost_per_sec",
+                    "tsl_ipt", "tsl_end_tsp", "tsl_opt", "tsl_cost", "tsl_cost_per_sec",
+                    "web_tsp", "web_src", "web_dst", "web_delay", "web_delay_per_sec", "web_freq"]]
         for i in self.items:
-            row_0, rows = i.to_rows()
-            all_rows.append(row_0)
-            all_rows += [astuple(i) for i in rows]
-            all_rows += [] # 每个 case后加一个空行
-
-            audios = [float(r.audio_length) for r in rows if r.audio_length]
-            transcribes = [float(r.tsb_cost) for r in rows if r.tsb_cost]
-            translates = [float(r.tsl_cost) for r in rows if r.tsl_cost]
-            if len(row_0) >=7:
-                summaries.append([row_0[1], row_0[6]-row_0[4], sum(audios), sum(transcribes), sum(translates)])
-            else:
-                summaries.append([row_0[1], 0, sum(audios), sum(transcribes), sum(translates)])
-        save_csv(csv_path, [], all_rows)
+            summary, detail_rows = i.to_rows()
+            summaries.append(astuple(summary))
+            details += [astuple(i) for i in detail_rows]
+            details.append([])
         self.print_summary(summaries)
+        save_csv(csv_path, [], summaries+[[]]+details)
 
 @dataclass
 class AccuracyItem:
@@ -188,9 +243,9 @@ class AccuracyItem:
         self.asr_accuracy = run_textdistance(self.audio_text, self.src_text)
         self.text_compare = highlight_diff(self.audio_text, self.src_text)
     def to_list(self):
-        return [self.translation_type, self.audio, self.audio_length, self.src_text,
-                # self.dst_text,
-                self.asr_accuracy, self.text_compare]
+        return [self.audio, self.translation_type, self.audio_length, self.src_text,
+                self.dst_text,
+                self.asr_accuracy[0], self.asr_accuracy[1], self.text_compare]
 
 class AccuracyReport:
     items:List[AccuracyItem] = []
@@ -201,7 +256,11 @@ class AccuracyReport:
         print(tabulate(rows, header))
 
     def to_csv(self, csv_path):
-        save_csv(csv_path, [], [i.to_list() for i in self.items])
+        print("accuracy item length: ", len(self.items))
         self.print_summary()
+        header = ["audio_name", "translation", "audio_length", "src text", "dst text",
+                  "distance", "normalized distance", "text compare"]
+        save_csv(csv_path, header, [i.to_list() for i in self.items])
+
 
 

lib/utils.py

@@ -22,7 +22,8 @@ def get_time_str(level:Literal["d","s","ms"]="d"):
 def save_csv(file_path, header, rows):
     with open(file_path, "w", encoding="utf-8") as f:
         writer = csv.writer(f)
-        writer.writerow(header)
+        if header:
+            writer.writerow(header)
         writer.writerows(rows)
         print(f"write csv to {file_path}")
 
@@ -63,3 +64,14 @@ def highlight_diff(a, b):
         elif tag == 'replace':
             output.append(f"[-{a[a_start:a_end]}-]{{+{b[b_start:b_end]}+}}")
     return ''.join(output)
+
+def time_to_float(s: str):
+    if d := s.replace("s", ""):
+        return float(d)
+    return 0.0
+
+
+if __name__ == '__main__':
+    a = ["1", "1.0", "10000.0 s", "", "2s", "3 s", "4    s", "5m"]
+    for i in a:
+        print(time_to_float(i))