Modif de la classe séquence et des scripts

l'utilisant

million/analyze/find_holes.py

 def compute_sequences(messages: List[Message], accepted_max: int = 1_000_000) -> List[Sequence]:
     sequences: List[Sequence] = []
     current_sequence = Sequence(
-        start = msg_ev.compute(messages[0]),
         start_message=messages[0],
-        end = msg_ev.compute(messages[0]),
         end_message=messages[0]
     )
     for i in range(1, len(messages)):
         message_value = msg_ev.compute(message)
         if message_value > accepted_max:
             continue
-        if message_value - current_sequence.end == 1:
-            current_sequence.end = message_value
+        if message_value - current_sequence.end() == 1:
             current_sequence.end_message = message
         else:
             sequences.append(current_sequence)
             current_sequence = Sequence(
-                start=message_value,
                 start_message=message,
-                end=message_value,
                 end_message=message
             )
 
     # order the sequences by start
-    sequences.sort(key=lambda s: s.start)
+    sequences.sort(key=lambda s: s.start())
 
     merged_sequences: List[Sequence] = []
     current_sequence = sequences[0]
     for i in range(1, len(sequences)):
         sequence = sequences[i]
-        sequence_start_is_in_current_sequence = current_sequence.start <= sequence.start and current_sequence.end >= sequence.start
-        sequence_end_is_further = sequence.end > current_sequence.end
-        sequence_start_is_current_end_or_next = sequence.start == current_sequence.end + 1
+        sequence_start_is_in_current_sequence = current_sequence.start() <= sequence.start() and current_sequence.end() >= sequence.start()
+        sequence_end_is_further = sequence.end() > current_sequence.end()
+        sequence_start_is_current_end_or_next = sequence.start() == current_sequence.end() + 1
 
         if sequence_start_is_in_current_sequence or sequence_start_is_current_end_or_next:
             if sequence_end_is_further:
-                current_sequence.end = sequence.end
                 current_sequence.end_message = sequence.end_message
         else:
             merged_sequences.append(current_sequence)
             current_sequence = sequence
 
     # Having merged the sequences once, any sequence having start = end can be removed
-    return [s for s in merged_sequences if s.start != s.end]
+    return [s for s in merged_sequences if s.start() != s.end()]
 
 
 def find_holes(messages: List[Message], accepted_max: int = 1_000_000) -> List[Hole]:
     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:
+        if sequence.start() - previous_sequence.end() > 1:
             holes.append(Hole(
-                start=previous_sequence.end,
-                end=sequence.start,
+                start=previous_sequence.end(),
+                end=sequence.start(),
                 start_message=previous_sequence.end_message,
                 end_message=sequence.start_message
             ))

million/model/sequence.py

 
-from typing import Optional
 from pydantic import BaseModel
 
 from million.model.message import Message
+import million.analyze.message_evaluation as msg_ev
 
 
 class Sequence(BaseModel):
-    start: int
     start_message: Message
-    end: int
-    end_message: Message
+    end_message: Message | None
+
+    def start(self) -> int:
+        return msg_ev.compute(self.start_message)
+    
+    def end(self) -> int:
+        return msg_ev.compute(self.end_message)

scripts/find_holes.py

 
 sequences = compute_sequences(filtered)
 
-actual_counted = sum([s.end - s.start for s in sequences])
+actual_counted = sum([s.end() - s.start() for s in sequences])
 
 print(f"Actual counted: {actual_counted}")