Atomisation du code

million/analyze/find_holes.py

@@ -7,44 +7,53 @@ import million.analyze.message_evaluation as msg_val
 
 
 def compute_sequences(messages: List[Message], accepted_max: int = 1_000_000) -> List[Sequence]:
-    sequences: List[Sequence] = []
-    current = Sequence(start_message=messages[0])
+    sequences: List[Sequence] = [Sequence(start_message=messages[0])]
     
     for message in messages[1:]:
         if msg_val.get(message) > accepted_max: continue
 
-        if msg_val.get(message) == current.end() + 1:
-            current.end_message = message
+        if msg_val.get(message) == sequences[-1].end() + 1:
+            sequences[-1].end_message = message
         else:
-            sequences.append(current)
-            current = Sequence(start_message=message)
+            sequences.append(Sequence(start_message=message))
 
-    sequences.sort(key=lambda s: s.start())
+    return sequences            
 
-    merged_sequences: List[Sequence] = []
-    previous = sequences[0]
-    
-    for sequence in sequences[1:]:
-        if previous.overlaps(sequence):
-            previous.merge(sequence)
+
+def merge_duplicates(sequences: List[Sequence]) -> List[Sequence]:
+    o_sequences = sorted(sequences, key= lambda s : s.start())
+    current = o_sequences[0]
+
+    result = []
+        
+    for sequence in o_sequences[1:]:
+        if current.overlaps(sequence):
+            current.merge(sequence)
         else:
-            merged_sequences.append(previous)
-            previous = sequence
+            result.append(current)
+            current = sequence
+
+    return result
 
-    return [s for s in merged_sequences if s.length() > 1]
 
 
+def invert_sequences(sequences: List[Sequence]) -> List[Sequence]:
+    result = []
+
+    for previous, current in zip(sequences[:-1],sequences[1:]):
+        result.append(Sequence(
+            start_message=previous.end_message,
+            end_message=current.start_message
+        ))
+
+    return result
+
 def find_holes(messages: List[Message], accepted_max: int = 1_000_000) -> List[Sequence]:
     """
     Find the holes in the conversation
     """
     sequences = compute_sequences(messages, accepted_max)
-    holes = []
-    
-    for previous, current in zip(sequences[:-1],sequences[1:]):
-        holes.append(Sequence(
-            start_message=previous.end_message,
-            end_message=current.start_message
-        ))
+    merged = merge_duplicates(sequences)
+    merged = [s for s in merged if s.length() > 1]
 
-    return holes
+    return invert_sequences(merged)

million/analyze/message_evaluation.py

@@ -7,8 +7,6 @@ memoization: Dict[Message, int] = {}
 # TODO WIP
 # - DNS to resolve audio, gif, pictures with counts
 def __compute__(msg: Message) -> int:
-    """ Returns the estimated value counted in this message
-    """
     value = None
     # Remove any number that is not a digit
     # TODO parse potential math expressions in content
@@ -23,4 +21,6 @@ def __compute__(msg: Message) -> int:
     return value
 
 def get(msg: Message) -> int:
+    """ Returns the estimated value counted in this message
+    """
     return memoization.get(msg, __compute__(msg))

scripts/find_holes.py

@@ -21,7 +21,7 @@ holes = find_holes(filtered)
 print(len(holes))
 
 for hole in holes:
-    print(f"{hole.start()} -> {hole.end()} ({hole.length()})")
+    print(f"{hole.start() + 1} -> {hole.end() - 1} ({hole.length() - 2})")
 
 
 # lets export a csv file of the holes and the people responsible for them