Uploading dataset files from the local data folder.

chunking.txt

@@ -0,0 +1,416 @@
+import json
+import logging
+import uuid
+import math
+import os
+import sys
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Set, Optional
+
+# -----------------------------------------------------------------------------
+# Imports & Dependency Checks
+# -----------------------------------------------------------------------------
+try:
+    import yaml
+except ImportError:
+    print("Error: 'PyYAML' is required. Install via 'pip install pyyaml'.")
+    sys.exit(1)
+
+try:
+    from openai import OpenAI, OpenAIError
+except ImportError:
+    print("Error: 'openai' is required. Install via 'pip install openai'.")
+    sys.exit(1)
+
+# We check for transformers inside the class to avoid crashing if 
+# the user wants heuristic mode but doesn't have transformers installed.
+try:
+    from transformers import AutoTokenizer
+    TRANSFORMERS_AVAILABLE = True
+except ImportError:
+    TRANSFORMERS_AVAILABLE = False
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logging.basicConfig(
+    level=logging.DEBUG, 
+    format='[%(levelname)s] %(asctime)s - %(funcName)s:%(lineno)d - %(message)s',
+    datefmt='%H:%M:%S'
+)
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# Configuration
+# -----------------------------------------------------------------------------
+
+@dataclass
+class ChunkingConfig:
+    """Configuration object loaded from YAML."""
+    api_key: str
+    llm_model_name: str
+    temperature: float
+    
+    # Tokenization
+    tokenizer_method: str 
+    hf_model_name: str
+    heuristic_chars_per_token: int
+    
+    # Limits
+    llm_token_limit: int
+    overlap_token_count: int
+    model_token_limit: int
+    
+    # Prompts
+    system_prompt_base: str
+
+    @classmethod
+    def from_yaml(cls, path: str) -> 'ChunkingConfig':
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"Config file not found at: {path}")
+
+        logger.info(f"Loading configuration from {path}...")
+        with open(path, 'r') as f:
+            data = yaml.safe_load(f)
+
+        oa = data.get('openai', {})
+        tok = data.get('tokenization', {})
+        tok_heu = tok.get('heuristic', {})
+        tok_hf = tok.get('huggingface', {})
+        lim = data.get('limits', {})
+        prompts = data.get('prompts', {})
+        
+        raw_key = oa.get('api_key', 'ENV')
+        api_key = os.getenv("OPENAI_API_KEY") if raw_key == "ENV" else raw_key
+
+        return cls(
+            api_key=api_key or "MISSING_KEY",
+            llm_model_name=oa.get('model_name', 'gpt-4o-mini'),
+            temperature=oa.get('temperature', 0.0),
+            
+            # Tokenizer Config
+            tokenizer_method=tok.get('method', 'heuristic'),
+            hf_model_name=tok_hf.get('model_name', 'gpt2'),
+            heuristic_chars_per_token=tok_heu.get('chars_per_token', 4),
+            
+            llm_token_limit=lim.get('llm_context_window', 300),
+            overlap_token_count=lim.get('window_overlap', 50),
+            model_token_limit=lim.get('target_chunk_size', 100),
+            
+            system_prompt_base=prompts.get('system_instructions', '')
+        )
+
+# -----------------------------------------------------------------------------
+# Data Structures
+# -----------------------------------------------------------------------------
+
+@dataclass
+class Line:
+    number: int
+    text: str
+    token_count: int
+
+@dataclass
+class PreChunkSegment:
+    lines: List[Line]
+    segment_id: str = field(default_factory=lambda: str(uuid.uuid4()))
+
+    @property
+    def formatted_text(self) -> str:
+        return "\n".join([f"{line.number} | {line.text}" for line in self.lines])
+
+@dataclass
+class SemanticGroup:
+    line_numbers: Set[int]
+
+# -----------------------------------------------------------------------------
+# Service Implementation
+# -----------------------------------------------------------------------------
+
+class DocumentChunkingService:
+    def __init__(self, config_path: str = "config.yaml"):
+        # 1. Load Config
+        try:
+            self.config = ChunkingConfig.from_yaml(config_path)
+        except Exception as e:
+            logger.critical(f"Failed to load config: {e}")
+            sys.exit(1)
+
+        # 2. Setup Tokenizer based on Method
+        self.hf_tokenizer = None
+        
+        if self.config.tokenizer_method == "huggingface":
+            if not TRANSFORMERS_AVAILABLE:
+                logger.critical("Config requests 'huggingface', but library is missing. Install 'transformers'.")
+                sys.exit(1)
+            
+            try:
+                logger.info(f"Initializing HuggingFace Tokenizer: {self.config.hf_model_name}")
+                os.environ["TOKENIZERS_PARALLELISM"] = "false"
+                self.hf_tokenizer = AutoTokenizer.from_pretrained(self.config.hf_model_name)
+            except Exception as e:
+                logger.critical(f"Failed to load HF Tokenizer: {e}")
+                sys.exit(1)
+                
+        elif self.config.tokenizer_method == "heuristic":
+            logger.info(f"Using Heuristic Tokenizer ({self.config.heuristic_chars_per_token} chars/token)")
+            
+        else:
+            logger.warning(f"Unknown tokenizer method '{self.config.tokenizer_method}'. Defaulting to heuristic.")
+
+        # 3. Setup OpenAI
+        if self.config.api_key == "MISSING_KEY":
+            logger.critical("No valid API Key found.")
+            self.client = None
+        else:
+            try:
+                self.client = OpenAI(api_key=self.config.api_key)
+            except Exception as e:
+                logger.error(f"Failed to initialize OpenAI Client: {e}")
+                sys.exit(1)
+
+    def _count_tokens(self, text: str) -> int:
+        """
+        Determines token count based on the configured method.
+        """
+        if not text:
+            return 0
+            
+        if self.config.tokenizer_method == "huggingface" and self.hf_tokenizer:
+            # HuggingFace Count
+            return len(self.hf_tokenizer.encode(text, add_special_tokens=False))
+        else:
+            # Heuristic Count
+            return math.ceil(len(text) / self.config.heuristic_chars_per_token)
+
+    def _prepare_lines(self, document_text: str) -> List[Line]:
+        logger.debug(f"Preparing lines using {self.config.tokenizer_method} method...")
+        raw_lines = document_text.split('\n')
+        processed_lines = []
+        
+        for idx, text in enumerate(raw_lines, start=1):
+            if not text.strip(): continue
+            count = self._count_tokens(text)
+            processed_lines.append(Line(idx, text, count))
+            
+        return processed_lines
+
+    def _create_pre_chunks(self, lines: List[Line]) -> List[PreChunkSegment]:
+        logger.debug(f"Segmenting lines (Limit: {self.config.llm_token_limit})...")
+        segments = []
+        current_segment_lines = []
+        current_tokens = 0
+        
+        i = 0
+        while i < len(lines):
+            line = lines[i]
+            
+            if current_tokens + line.token_count > self.config.llm_token_limit and current_segment_lines:
+                segments.append(PreChunkSegment(list(current_segment_lines)))
+                
+                # Overlap Logic
+                overlap_buffer = []
+                overlap_tokens = 0
+                back_idx = i - 1
+                while back_idx >= 0:
+                    prev_line = lines[back_idx]
+                    if prev_line in current_segment_lines:
+                        overlap_buffer.insert(0, prev_line)
+                        overlap_tokens += prev_line.token_count
+                        if overlap_tokens >= self.config.overlap_token_count:
+                            break
+                    else:
+                        break
+                    back_idx -= 1
+                
+                current_segment_lines = list(overlap_buffer)
+                current_tokens = overlap_tokens
+            
+            current_segment_lines.append(line)
+            current_tokens += line.token_count
+            i += 1
+            
+        if current_segment_lines:
+            segments.append(PreChunkSegment(current_segment_lines))
+            
+        return segments
+
+    def _call_openai(self, segment_text: str, available_lines: List[int]) -> List[List[int]]:
+        runtime_constraint = f"\nCRITICAL CONSTRAINT: Only use the line numbers provided in this specific range: {available_lines}"
+        full_system_prompt = self.config.system_prompt_base + runtime_constraint
+        user_prompt = f"Input Lines:\n{segment_text}\n\nOutput JSON:"
+
+        try:
+            logger.debug(f"Calling OpenAI (Lines {available_lines[0]}-{available_lines[-1]})...")
+            response = self.client.chat.completions.create(
+                model=self.config.llm_model_name,
+                messages=[
+                    {"role": "system", "content": full_system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                response_format={"type": "json_object"},
+                temperature=self.config.temperature
+            )
+            parsed = json.loads(response.choices[0].message.content)
+            groups = parsed.get("groups", [])
+            
+            if isinstance(groups, list) and all(isinstance(g, list) for g in groups):
+                return groups
+            return [[l] for l in available_lines]
+        except Exception as e:
+            logger.error(f"OpenAI Call Failed: {e}")
+            return [[l] for l in available_lines]
+
+    def _get_semantic_groupings(self, segments: List[PreChunkSegment]) -> List[List[int]]:
+        all_raw_groups = []
+        for idx, seg in enumerate(segments):
+            available_lines = [l.number for l in seg.lines]
+            response_groups = self._call_openai(seg.formatted_text, available_lines)
+            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
+
+        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))
+
+    def _finalize_chunk(self, content: str, line_numbers: List[int], parent_id: Optional[str] = None) -> List[Dict[str, Any]]:
+        count = self._count_tokens(content)
+        
+        if count <= self.config.model_token_limit:
+            return [{
+                "content": content,
+                "line_numbers": line_numbers,
+                "token_estimate": count,
+                "metadata": {"parent_id": parent_id}
+            }]
+        
+        if len(line_numbers) <= 1:
+            return [{
+                "content": content,
+                "line_numbers": line_numbers,
+                "token_estimate": count,
+                "metadata": {"parent_id": parent_id, "warning": "oversized"}
+            }]
+
+        mid = len(line_numbers) // 2
+        left_lines = line_numbers[:mid]
+        right_lines = line_numbers[mid:]
+        
+        left_text = "\n".join([self.current_doc_map[n].text for n in left_lines])
+        right_text = "\n".join([self.current_doc_map[n].text for n in right_lines])
+        
+        cid = parent_id if parent_id else str(uuid.uuid4())[:8]
+        results = []
+        results.extend(self._finalize_chunk(left_text, left_lines, parent_id=cid))
+        results.extend(self._finalize_chunk(right_text, right_lines, parent_id=cid))
+        return results
+
+    def process_document(self, plaintext: str) -> str:
+        logger.info(f">>> Processing Document [Mode: {self.config.tokenizer_method.upper()}]")
+        lines = self._prepare_lines(plaintext)
+        self.current_doc_map = {l.number: l for l in lines}
+        
+        pre_chunks = self._create_pre_chunks(lines)
+        raw_groups = self._get_semantic_groupings(pre_chunks)
+        merged_groups = self._resolve_overlaps(raw_groups, self.current_doc_map)
+        
+        final_output = []
+        logger.info("Finalizing chunks...")
+        for group in merged_groups:
+            sorted_nums = sorted(list(group.line_numbers))
+            text_content = "\n".join([self.current_doc_map[n].text for n in sorted_nums])
+            chunks = self._finalize_chunk(text_content, sorted_nums)
+            final_output.extend(chunks)
+            
+        logger.info(f"<<< Done. Generated {len(final_output)} chunks.")
+        return json.dumps(final_output, indent=2)
+
+# -----------------------------------------------------------------------------
+# Main Execution
+# -----------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    sample_text = """The history of Artificial Intelligence is fascinating.
+It begins with the Turing Test proposed by Alan Turing.
+Early AI research focused on symbolic logic and problem solving.
+However, computing power was limited in the 1950s.
+Decades later, machine learning emerged as a dominant paradigm.
+Neural networks, inspired by the human brain, gained popularity.
+Deep learning revolutionized the field in the 2010s.
+Transformers, introduced by Google, changed NLP forever.
+Large Language Models like GPT-4 are now commonplace.
+Retrieval Augmented Generation allows LLMs to use external data.
+Chunking documents is essential for RAG systems.
+It preserves semantic meaning during retrieval.
+This specific code implements a rigorous chunking strategy.
+It uses heuristic strategies for token estimation.
+The end goal is high quality embeddings."""
+    
+    service = DocumentChunkingService("config.yaml")
+    
+    if service.client:
+        result = service.process_document(sample_text)
+        print("\n--- Final Output JSON ---")
+        print(result)
+
+
+
+
+openai:
+  api_key: "ENV"
+  model_name: "gpt-4o-mini"
+  temperature: 0.0
+
+tokenization:
+  # MASTER SWITCH: Choose "heuristic" or "huggingface"
+  # - "heuristic": Uses simple math (chars / chars_per_token). Fast, no dependencies.
+  # - "huggingface": Uses a real tokenizer (e.g., gpt2). Precise, requires 'transformers' lib.
+  method: "heuristic"
+  
+  # Settings for "heuristic" method
+  heuristic:
+    chars_per_token: 4
+  
+  # Settings for "huggingface" method
+  huggingface:
+    # "gpt2" is a standard proxy for general LLM token counting
+    model_name: "gpt2"
+
+limits:
+  # Max tokens to send to OpenAI in one request (chunk context window)
+  llm_context_window: 300
+  # Overlap between context windows to prevent cutting sentences
+  window_overlap: 50
+  # The target max size for a final, atomic chunk
+  target_chunk_size: 100
+
+prompts:
+  system_instructions: |
+    You are a document chunking assistant. Your goal is to group lines of text into semantically coherent chunks.
+    
+    Strict Rules:
+    1. Every line number provided in the input must appear exactly once in your output.
+    2. Group line numbers that belong together conceptually.
+    3. Return a JSON object with a single key 'groups' containing a list of lists of integers.