deleted useless hole class

million/analyze/find_holes.py

 
 
 from typing import List
-from million.model.hole import Hole
 from million.model.message import Message
 from million.model.sequence import Sequence
 import million.analyze.message_evaluation as msg_val
             sequences.append(current)
             current = Sequence(start_message=message)
 
-    # order the sequences by start
     sequences.sort(key=lambda s: s.start())
 
     merged_sequences: List[Sequence] = []
             merged_sequences.append(previous)
             previous = sequence
 
-    # Having merged the sequences once, any sequence having start = end can be removed
     return [s for s in merged_sequences if s.length() > 1]
 
 
-def find_holes(messages: List[Message], accepted_max: int = 1_000_000) -> List[Hole]:
+def find_holes(messages: List[Message], accepted_max: int = 1_000_000) -> List[Sequence]:
     """
     Find the holes in the conversation
     """
-    merged_sequences = compute_sequences(messages, accepted_max)
+    sequences = compute_sequences(messages, accepted_max)
     holes = []
-    for i in range(1, len(merged_sequences)):
-        previous_sequence = merged_sequences[i - 1]
-        sequence = merged_sequences[i]
-        if sequence.start() - previous_sequence.end() > 1:
-            holes.append(Hole(
-                start=previous_sequence.end(),
-                end=sequence.start(),
-                start_message=previous_sequence.end_message,
-                end_message=sequence.start_message
-            ))
+    
+    for previous, current in zip(sequences[:-1],sequences[1:]):
+        holes.append(Sequence(
+            start_message=previous.end_message,
+            end_message=current.start_message
+        ))
+
     return holes

million/model/hole.py

-
-from pydantic import BaseModel
-
-from million.model.message import Message
-
-
-class Hole(BaseModel):
-    start: int
-    end: int
-    start_message: Message
-    end_message: Message

scripts/find_holes.py

 from datetime import datetime
 from million.analyze.find_holes import compute_sequences, find_holes
-from million.view.bar_chart import plot as bar_chart
-from million.analyze.count_participations import count_participations
 from million.analyze.retain_counts import retain_counts
 import million.parse.fb_exports as fb
 
 
 sequences = compute_sequences(filtered)
 
-actual_counted = sum([s.end() - s.start() for s in sequences])
+actual_counted = sum([s.length() for s in sequences])
 
 print(f"Actual counted: {actual_counted}")
 
 print(len(holes))
 
 for hole in holes:
-    print(f"{hole.start} - {hole.end} ({hole.end - hole.start})")
+    print(f"{hole.start()} -> {hole.end()} ({hole.length()})")
 
 
 # lets export a csv file of the holes and the people responsible for them
         date_end = datetime.utcfromtimestamp(
             hole.end_message.timestamp_ms / 1000.0).strftime('%Y-%m-%d %H:%M:%S')
         f.write(
-            f"{hole.start},"
-            f"{hole.end},"
-            f"{hole.end - hole.start},"
+            f"{hole.start()},"
+            f"{hole.end()},"
+            f"{hole.length()},"
             f"{hole.start_message.sender_name},"
             f"{hole.end_message.sender_name},"
             f"{date_start},{date_end}\n"