ajout de memoization

million/analyze/find_holes.py

 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_ev
+import million.analyze.message_evaluation as msg_val
 
 
 def compute_sequences(messages: List[Message], accepted_max: int = 1_000_000) -> List[Sequence]:
     current = Sequence(start_message=messages[0])
     
     for message in messages[1:]:
-        if msg_ev.compute(message) > accepted_max: continue
+        if msg_val.get(message) > accepted_max: continue
 
-        if msg_ev.compute(message) == current.end() + 1:
+        if msg_val.get(message) == current.end() + 1:
             current.end_message = message
         else:
             sequences.append(current)

million/analyze/message_evaluation.py

 from math import floor
+from typing import Dict
 from million.model.message import Message
 
+memoization: Dict[Message, int] = {}
+
 # TODO WIP
 # - DNS to resolve audio, gif, pictures with counts
-def compute(msg: Message) -> int:
+def __compute__(msg: Message) -> int:
     """ Returns the estimated value counted in this message
     """
     value = None
     except Exception as e:
         raise ValueError(
             f"Message {cleaned_content} does not contain a number ({e})")
-    return value
+    
+    memoization[msg] = value
+    return value
+
+def get(msg: Message) -> int:
+    return memoization.get(msg, __compute__(msg))

million/model/message.py

         dt = datetime.fromtimestamp(self.timestamp_ms / 1000)
         dt_str = dt.strftime("%d/%m/%Y, %H:%M:%S")
         return f"{self.sender_name}({dt_str}) : {self.content}"
+
+    def __hash__(self) -> int:
+        return hash(self.sender_name + str(self.timestamp_ms))

million/model/sequence.py

 import pydantic
 
 from million.model.message import Message
-import million.analyze.message_evaluation as msg_ev
+import million.analyze.message_evaluation as msg_val
 
 
 class Sequence(BaseModel):
         return v or values['start_message'] 
 
     def start(self) -> int:
-        return msg_ev.compute(self.start_message)
+        return msg_val.get(self.start_message)
     
     def end(self) -> int:
-        return msg_ev.compute(self.end_message)
+        return msg_val.get(self.end_message)
     
     def length(self) -> int:
         return self.end() - self.start() + 1