Uploading dataset files from the local data folder.

chunking.txt

@@ -269,31 +269,63 @@ class DocumentChunkingService:
             all_raw_groups.extend(response_groups)
         return all_raw_groups
 
-    def _resolve_overlaps(self, raw_groups: List[List[int]], all_lines_map: Dict[int, Line]) -> List[SemanticGroup]:
-        parent = {line_num: line_num for line_num in all_lines_map.keys()}
-        def find(i):
-            if parent[i] == i: return i
-            parent[i] = find(parent[i])
-            return parent[i]
-        def union(i, j):
-            root_i = find(i)
-            root_j = find(j)
-            if root_i != root_j: parent[root_j] = root_i
+    def resolve_overlaps(raw_groups: List[List[int]], all_lines_map: Dict[int, Line]) -> List[SemanticGroup]:
+        """
+        Merges groups based on overlapping line number ranges.
+        Uses a standard 'Merge Intervals' algorithm.
+        """
+        intervals: List[GroupInterval] = []
 
+        # 1. Convert raw groups to Intervals
         for group in raw_groups:
-            if not group: continue
-            valid_group = [g for g in group if g in parent]
-            if not valid_group: continue
-            first = valid_group[0]
-            for other in valid_group[1:]:
-                union(first, other)
-
-        clusters: Dict[int, Set[int]] = {}
-        for line_num in all_lines_map.keys():
-            root = find(line_num)
-            if root not in clusters: clusters[root] = set()
-            clusters[root].add(line_num)
-        return sorted([SemanticGroup(lines) for lines in clusters.values()], key=lambda x: min(x.line_numbers))
+            if not group:
+                continue
+            
+            # Filter for valid lines only
+            valid_lines = {g for g in group if g in all_lines_map}
+            if not valid_lines:
+                continue
+                
+            # Define range based on min and max line numbers in the group
+            intervals.append(GroupInterval(
+                start=min(valid_lines),
+                end=max(valid_lines),
+                line_numbers=valid_lines
+            ))
+
+        if not intervals:
+            return []
+
+        # 2. Sort by start time
+        intervals.sort(key=lambda x: x.start)
+
+        # 3. Merge overlapping intervals
+        merged: List[GroupInterval] = []
+        
+        for current in intervals:
+            if not merged:
+                merged.append(current)
+                continue
+            
+            last = merged[-1]
+
+            # Check for overlap: 
+            # If current starts before (or exactly when) last ends, they overlap.
+            # e.g. [84, 795] and [788, 887] -> 788 <= 795, so merge.
+            if current.start <= last.end:
+                # Merge logic:
+                # 1. Extend the end if needed
+                last.end = max(last.end, current.end)
+                # 2. Combine the sets of line numbers
+                last.line_numbers.update(current.line_numbers)
+            else:
+                # No overlap, start a new cluster
+                merged.append(current)
+
+        # 4. Convert back to SemanticGroups
+        results = [SemanticGroup(group.line_numbers) for group in merged]
+        return sorted(results, key=lambda x: min(x.line_numbers) if x.line_numbers else 0)
+
 
     def _finalize_chunk(self, content: str, line_numbers: List[int], parent_id: Optional[str] = None) -> List[Dict[str, Any]]:
         count = self._count_tokens(content)