Normalize stern neon articles through external LLM w/ code in ./scripts

.gitignore

@@ -0,0 +1 @@
+**/*.env

README.md

@@ -1,15 +1,20 @@
 ---
-license: unknown
+license: wtfpl
 task_categories:
 - text-classification
-- question-answering
+- summarization
 - text-generation
-- text2text-generation
+- sentence-similarity
 language:
 - de
+- en
 tags:
 - art
-pretty_name: Structured Stern NEON Community Articles
+- poetry
+- literature
+- articles
+- opinion
+pretty_name: Stern NEON Articles
 size_categories:
 - 10K<n<100K
 ---
@@ -161,6 +166,59 @@ wird doch alles besser und gut und dann werde ich auch gesünder aussehen.
 Morgen fängt das schon an.
 ```
 
+## JSONL Normalization Script
+
+A Python script (`normalize_jsonl.py`) is included in this repository to help clean and prepare the dataset for LLM fine-tuning. This script uses an OpenAI-compatible API to normalize the `text` field of each entry, ensuring high-quality, consistent data for model training.
+
+### Features
+- **Filters entries**: Skips entries with empty or missing `text` fields
+- **State tracking**: Skips already processed entries (marked as normalized or failed) to avoid duplicate work and API calls
+- **AI-powered normalization**: Uses OpenAI or compatible APIs to clean, standardize, and preserve the literary quality of the text
+- **Error handling**: Entries that fail normalization are saved to a separate file
+- **Progress logging**: Detailed logs and progress updates are written to `normalize_log.txt`
+- **Rate limiting**: Adjustable delay between API calls to respect rate limits
+- **Force reprocessing**: Optionally reprocess all entries, ignoring previous state
+
+### Usage
+
+1. **Install dependencies**
+   ```bash
+   pip install -r requirements.txt
+   ```
+2. **Set your API key**
+   - Export as environment variable: `export OPENAI_API_KEY="your-api-key"`
+   - Or use the `--api-key` flag
+3. **Run the script**
+   ```bash
+   python normalize_jsonl.py stern_neon_user_poetry.jsonl
+   ```
+   This will create:
+   - `normalized_entries.jsonl` — Successfully normalized entries
+   - `failed_normalizations.jsonl` — Entries that failed normalization
+   - `normalize_log.txt` — Detailed log of the process
+
+#### Command Line Options
+- `input_file` — Path to input JSONL file (required)
+- `-o, --output` — Output file for normalized entries (default: normalized_entries.jsonl)
+- `-f, --failed` — Output file for failed entries (default: failed_normalizations.jsonl)
+- `-k, --api-key` — OpenAI API key (or set OPENAI_API_KEY env var)
+- `-u, --base-url` — Base URL for OpenAI-compatible API (for local models, etc.)
+- `-m, --model` — Model to use (default: gpt-3.5-turbo)
+- `--max-entries` — Maximum entries to process (for testing)
+- `--delay` — Delay between API calls in seconds (default: 0.5)
+- `--force-reprocess` — Force reprocessing of already normalized entries
+
+#### State Handling & Resume
+- The script automatically skips already processed entries (normalized or failed), allowing you to resume processing if interrupted.
+- To reprocess all entries, use the `--force-reprocess` flag.
+
+#### Example
+```bash
+python normalize_jsonl.py stern_neon_user_poetry.jsonl --max-entries 10
+```
+
+See the script source for more details and customization options.
+
 ## Dataset Creation
 
 ### Curation Rationale

scripts/README_MONGODB.md

@@ -0,0 +1,91 @@
+# MongoDB Setup for Stern Neon Dataset
+
+This guide explains how to set up MongoDB using Docker and import your JSONL dataset.
+
+## Prerequisites
+
+- Docker and Docker Compose installed
+- Python 3.6+ with pip
+- JSONL dataset file (e.g., `stern_neon_user_poetry.jsonl`)
+
+## Setup Instructions
+
+### 1. Start MongoDB with Docker Compose
+
+```bash
+# Start the MongoDB container and Mongo Express web UI
+docker-compose up -d
+```
+
+This will start:
+- MongoDB server on port 27017
+- Mongo Express web UI on port 8081
+
+### 2. Install Python Dependencies
+
+```bash
+# Install required Python package
+pip install pymongo
+```
+
+### 3. Import JSONL Data into MongoDB
+
+```bash
+# Import the default file (stern_neon_user_poetry.jsonl)
+python import_jsonl_to_mongodb.py
+
+# Or specify a different file
+python import_jsonl_to_mongodb.py normalized_entries.jsonl
+```
+
+## Accessing MongoDB
+
+### Connection Details
+
+- **Host**: localhost
+- **Port**: 27017
+- **Username**: admin
+- **Password**: password
+- **Database**: stern_neon_db
+- **Collection**: articles
+
+### Using Mongo Express
+
+Access the web UI at: http://localhost:8081
+
+### Using MongoDB Shell
+
+```bash
+# Connect to MongoDB container
+docker exec -it mongo mongosh -u admin -p password
+
+# Select database
+use stern_neon_db
+
+# Query documents
+db.articles.find().limit(5)
+```
+
+## Environment Variables
+
+You can customize the MongoDB connection by setting these environment variables:
+
+```bash
+export MONGO_HOST=localhost
+export MONGO_PORT=27017
+export MONGO_USER=admin
+export MONGO_PASSWORD=password
+export MONGO_DB=stern_neon_db
+export MONGO_COLLECTION=articles
+```
+
+## Data Structure
+
+The imported documents will maintain the same structure as in your JSONL file, with each entry having fields like:
+- `id`: Unique identifier
+- `title`: Article title
+- `subtitle`: Article subtitle
+- `text`: Main content
+- Other fields from your dataset
+
+An index is automatically created on the `id` field for faster lookups.

scripts/docker-compose.yml

@@ -0,0 +1,44 @@
+name: structured-stern-neon-articles
+
+services:
+  mongo:
+    image: mongodb/mongodb-community-server:latest
+    restart: always
+    env_file:
+      - mongodb.env
+    ports:
+      - "27017:27017"
+    volumes:
+      - mongodb_data:/data/db
+    networks:
+      - mongo_network
+
+  mongo-express:
+    image: mongo-express:latest
+    restart: always
+    ports:
+      - "8081:8081"
+    
+    environment:
+      ME_CONFIG_MONGODB_ENABLE_ADMIN: true
+      ME_CONFIG_MONGODB_AUTH_USERNAME: admin
+      ME_CONFIG_MONGODB_AUTH_PASSWORD: password
+      ME_CONFIG_MONGODB_URL: mongodb://admin:password@mongo:27017/
+
+      ME_CONFIG_BASICAUTH_ENABLED: true
+      ME_CONFIG_BASICAUTH_USERNAME: mongoexpressuser
+      ME_CONFIG_BASICAUTH_PASSWORD: mongoexpresspass
+
+    depends_on:
+      - mongo
+    
+    networks:
+      - mongo_network
+
+
+networks:
+  mongo_network:
+    driver: bridge
+
+volumes:
+  mongodb_data:

scripts/import_jsonl_to_mongodb.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+"""
+Import JSONL data into MongoDB.
+Usage: python import_jsonl_to_mongodb.py [jsonl_file]
+"""
+import json
+import sys
+from pymongo import MongoClient
+import os
+
+# Default file if not specified
+DEFAULT_JSONL_FILE = 'stern_neon_user_poetry.jsonl'
+
+def import_jsonl_to_mongodb(jsonl_file):
+    """Import JSONL data into MongoDB."""
+    # MongoDB connection settings
+    mongo_host = os.environ.get('MONGO_HOST', 'localhost')
+    mongo_port = int(os.environ.get('MONGO_PORT', 27017))
+    mongo_user = os.environ.get('MONGO_USER', 'admin')
+    mongo_password = os.environ.get('MONGO_PASSWORD', 'password')
+    mongo_db = os.environ.get('MONGO_DB', 'stern_neon_db')
+    mongo_collection = os.environ.get('MONGO_COLLECTION', 'articles')
+    
+    # Connect to MongoDB
+    connection_string = f"mongodb://{mongo_user}:{mongo_password}@{mongo_host}:{mongo_port}/?authSource=admin"
+    client = MongoClient(connection_string)
+    db = client[mongo_db]
+    collection = db[mongo_collection]
+    
+    # Read and import JSONL file
+    count = 0
+    batch_size = 10
+    batch = []
+    
+    print(f"Importing data from {jsonl_file} to MongoDB ({mongo_host}:{mongo_port})...")
+    print(f"Database: {mongo_db}, Collection: {mongo_collection}")
+    
+    with open(jsonl_file, 'r', encoding='utf-8') as f:
+        for line_num, line in enumerate(f, 1):
+            if not line.strip():
+                continue
+                
+            try:
+                # Parse JSON line
+                document = json.loads(line)
+                
+                # Add to batch
+                batch.append(document)
+                count += 1
+                
+                # Insert batch when it reaches batch_size
+                if len(batch) >= batch_size:
+                    collection.insert_many(batch)
+                    print(f"Imported {count} documents...")
+                    batch = []
+                    
+            except json.JSONDecodeError as e:
+                print(f"Error parsing line {line_num}: {e}")
+            except Exception as e:
+                print(f"Error importing line {line_num}: {e}")
+    
+    # Insert remaining documents
+    if batch:
+        collection.insert_many(batch)
+    
+    print(f"Import complete. Total documents imported: {count}")
+    
+    # Create index on 'id' field for faster lookups
+    if count > 0:
+        print("Creating index on 'id' field...")
+        collection.create_index('id')
+        print("Index created.")
+
+if __name__ == '__main__':
+    # Get JSONL file from command line argument or use default
+    jsonl_file = sys.argv[1] if len(sys.argv) > 1 else DEFAULT_JSONL_FILE
+    
+    if not os.path.exists(jsonl_file):
+        print(f"Error: File '{jsonl_file}' not found.")
+        sys.exit(1)
+        
+    import_jsonl_to_mongodb(jsonl_file)

scripts/normalize.env.example

@@ -0,0 +1,10 @@
+MONGODB_HOST=localhost
+MONGODB_PORT=27017
+MONGODB_USER=admin
+MONGODB_PASSWORD=password
+MONGODB_DATABASE=stern_neon_db
+MONGODB_COLLECTION=articles
+
+OPENAI_API_URL=
+OPENAI_API_KEY=
+OPENAI_MODEL=

scripts/normalize_articles.py

@@ -0,0 +1,314 @@
+#!/usr/bin/env python3
+"""
+Normalize MongoDB `articles` documents for LLM fine-tuning using an OpenAI-compatible API.
+Supports concurrent processing with configurable concurrency level.
+
+Environment variables:
+  - MONGO_HOST (default: localhost)
+  - MONGO_PORT (default: 27017)
+  - MONGO_USER (default: admin)
+  - MONGO_PASSWORD (default: password)
+  - MONGO_DB (default: stern_neon_db)
+  - MONGO_COLLECTION (default: articles)
+  - OPENAI_API_KEY (required)
+  - OPENAI_BASE_URL (optional; e.g., http://localhost:11434/v1)
+  - OPENAI_MODEL (default: gpt-4o-mini)
+
+Usage examples:
+  python normalize_articles.py --limit 100 --dry-run
+  python normalize_articles.py --resume-from 652e... --batch-size 20 --concurrency 5
+"""
+import argparse
+import asyncio
+import os
+import sys
+import time
+from typing import Any, Dict, Optional, List, Tuple
+
+from pymongo import MongoClient
+from pymongo.collection import Collection
+from bson import ObjectId
+
+import aiohttp
+
+
+def load_env_file(env_path: str) -> None:
+    """Load key=value pairs from a .env-like file into os.environ.
+
+    Lines starting with '#' or empty lines are ignored. Keys and values are stripped.
+    Values are not unescaped; simple literal assignment only.
+    """
+    if not env_path:
+        return
+    if not os.path.exists(env_path):
+        return
+    try:
+        with open(env_path, 'r', encoding='utf-8') as f:
+            for raw_line in f:
+                line = raw_line.strip()
+                if not line or line.startswith('#'):
+                    continue
+                if '=' not in line:
+                    continue
+                key, value = line.split('=', 1)
+                key = key.strip()
+                value = value.strip()
+                os.environ[key] = value
+    except Exception as e:
+        print(f"Warning: failed to load env file '{env_path}': {e}")
+
+
+def get_mongo_collection() -> Collection:
+    # Support both MONGODB_* and MONGO_* names, prefer MONGODB_* if present
+    mongo_host = os.environ.get('MONGODB_HOST') or os.environ.get('MONGO_HOST', 'localhost')
+    mongo_port = int(os.environ.get('MONGODB_PORT') or os.environ.get('MONGO_PORT', 27017))
+    mongo_user = os.environ.get('MONGODB_USER') or os.environ.get('MONGO_USER', 'admin')
+    mongo_password = os.environ.get('MONGODB_PASSWORD') or os.environ.get('MONGO_PASSWORD', 'password')
+    mongo_db = os.environ.get('MONGODB_DATABASE') or os.environ.get('MONGO_DB', 'stern_neon_db')
+    mongo_collection = os.environ.get('MONGODB_COLLECTION') or os.environ.get('MONGO_COLLECTION', 'articles')
+
+    connection_string = f"mongodb://{mongo_user}:{mongo_password}@{mongo_host}:{mongo_port}/?authSource=admin"
+    client = MongoClient(connection_string)
+    db = client[mongo_db]
+    return db[mongo_collection]
+
+
+async def normalize_text_via_openai_compatible(text: str, api_key: str, base_url: Optional[str], model: str, session: aiohttp.ClientSession, timeout: int = 60) -> str:
+    """Send text to an OpenAI-compatible Chat Completions API and return normalized text.
+
+    The function uses a simple prompt to clean and normalize content for LLM fine-tuning.
+    """
+    url = (base_url.rstrip('/') if base_url else 'https://api.openai.com/v1') + '/chat/completions'
+    headers = {
+        'Authorization': f'Bearer {api_key}',
+        'Content-Type': 'application/json',
+    }
+    payload = {
+        'model': model,
+        'temperature': 0.1,
+        'messages': [
+            {
+                'role': 'system',
+                'content': (
+                    'You are a precise text normalization assistant for preparing training data for LLM fine-tuning.\n'
+                    'TASK: Normalize ONLY the provided main article text. Return ONLY the normalized text with no extra commentary, no markdown, no metadata.\n'
+                    'REQUIREMENTS:\n'
+                    '1) Fix obvious typos and spelling errors.\n'
+                    '2) Normalize punctuation and spacing inconsistencies.\n'
+                    '3) Remove excessive whitespace/newlines, but preserve intentional line breaks for poetry and paragraphs.\n'
+                    '   - Allow at most three consecutive empty lines.\n'
+                    '4) Ensure proper capitalization where appropriate.\n'
+                    '5) Fix encoding issues or strange characters.\n'
+                    '6) Maintain the original meaning, literary quality, style, and voice.\n'
+                    '7) Preserve intentional formatting (e.g., poetry line breaks), but avoid over-spacing.\n'
+                    '8) Remove any metadata or non-content text (e.g., headers, footers, navigation, ads).\n'
+                    '9) Normalize quote characters to straight ASCII single (\'\') and double (\"\") quotes.\n'
+                    'CONSTRAINTS: Do not add content. Do not summarize. Do not rephrase stylistically beyond necessary corrections. Output plain text only.'
+                ),
+            },
+            {
+                'role': 'user',
+                'content': text,
+            },
+        ],
+    }
+
+    print(f"Sending text to {url} with model {model}")
+
+    try:
+        async with session.post(url, json=payload, headers=headers, timeout=aiohttp.ClientTimeout(total=timeout)) as resp:
+            if resp.status != 200:
+                response_text = await resp.text()
+                raise RuntimeError(f"OpenAI-compatible API error: {resp.status} {response_text}")
+            
+            data = await resp.json()
+            try:
+                content = data['choices'][0]['message']['content']
+                return content.strip()
+            except Exception:
+                raise RuntimeError(f"Unexpected API response format: {data}")
+    except asyncio.TimeoutError:
+        raise RuntimeError(f"Request timeout after {timeout} seconds")
+    except Exception as e:
+        raise RuntimeError(f"Request failed: {e}")
+
+
+def normalize_quote_characters(text: str) -> str:
+    """Normalize various curly and localized quotes to straight ASCII quotes.
+
+    This is a deterministic post-process to ensure consistent quotes regardless of model behavior.
+    """
+    if not text:
+        return text
+    replacements = {
+        '“': '"', '”': '"', '„': '"', '‟': '"', '«': '"', '»': '"',
+        '‟': '"', '＂': '"',
+        '‘': '\'', '’': '\'', '‚': '\'', '‛': '\'', '‹': '\'', '›': '\'', '＇': '\'',
+    }
+    out = text
+    for src, dst in replacements.items():
+        out = out.replace(src, dst)
+    return out
+
+
+def build_revision(original: Dict[str, Any], normalized_text: str) -> Dict[str, Any]:
+    """Return a new revision object to be stored alongside the original under the same _id.
+
+    Stores a minimal revision metadata and the normalized text. Does not overwrite original fields.
+    """
+    return {
+        'revision_type': 'normalized',
+        'normalized_at': int(time.time()),
+        'source_fields': ['text'],
+        'text': normalized_text,
+    }
+
+
+async def process_single_document(doc: Dict[str, Any], api_key: str, base_url: Optional[str], model: str, session: aiohttp.ClientSession, dry_run: bool, collection: Collection) -> bool:
+    """Process a single document for normalization."""
+    text = str(doc.get('text', '')).strip()
+    if not text:
+        return False
+
+    try:
+        normalized = await normalize_text_via_openai_compatible(text, api_key=api_key, base_url=base_url, model=model, session=session)
+        normalized = normalize_quote_characters(normalized)
+    except Exception as e:
+        print(f"_id={doc.get('_id')} normalization failed: {e}")
+        return False
+
+    revision = build_revision(doc, normalized)
+
+    update = {
+        '$push': { 'revisions': revision }
+    }
+
+    if dry_run:
+        print(f"DRY-RUN _id={doc.get('_id')} would append a normalized revision")
+        print("--- ORIGINAL TEXT ---")
+        print(text)
+        print("--- NORMALIZED TEXT ---")
+        print(normalized)
+        print("======================\n")
+    else:
+        print(f"Updating _id={doc.get('_id')} with normalized text")
+        collection.update_one({ '_id': doc['_id'] }, update)
+
+    return True
+
+
+async def process_documents_batch(docs: List[Dict[str, Any]], api_key: str, base_url: Optional[str], model: str, dry_run: bool, collection: Collection, semaphore: asyncio.Semaphore) -> int:
+    """Process a batch of documents concurrently."""
+    
+    print(f"Processing batch of {len(docs)} documents")
+    async def process_with_semaphore(doc):
+        async with semaphore:
+            async with aiohttp.ClientSession() as session:
+                return await process_single_document(doc, api_key, base_url, model, session, dry_run, collection)
+    
+    tasks = [process_with_semaphore(doc) for doc in docs]
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+    
+    # Count successful normalizations
+    successful = sum(1 for result in results if result is True)
+    return successful
+
+
+def process_documents(collection: Collection, limit: Optional[int], resume_from: Optional[str], batch_size: int, dry_run: bool, api_key: str, base_url: Optional[str], model: str, concurrency: int = 5) -> None:
+    async def run_async_processing():
+        query: Dict[str, Any] = {
+            # skip docs without text or with empty/whitespace-only text
+            'text': { '$type': 'string', '$regex': r'\S' },
+            # only process documents that do NOT already contain a normalized revision
+            '$or': [
+                { 'revisions': { '$exists': False } },
+                { 'revisions': { '$not': { '$elemMatch': { 'revision_type': 'normalized' } } } },
+            ],
+        }
+        if resume_from:
+            try:
+                query['_id'] = { '$gt': ObjectId(resume_from) }
+            except Exception:
+                print(f"Warning: invalid --resume-from ObjectId: {resume_from}. Ignoring.")
+
+        # Print amount of documents to process
+        print(f"Processing {collection.count_documents(query)} documents")
+
+        cursor = collection.find(query, no_cursor_timeout=True).sort('_id', 1)
+        processed = 0
+        batch: List[Dict[str, Any]] = []
+        semaphore = asyncio.Semaphore(concurrency)
+        
+        try:
+            for doc in cursor:
+                if limit is not None and processed >= limit:
+                    break
+                
+                batch.append(doc)
+                
+                # Process batch when it reaches batch_size or we're at the end
+                if len(batch) >= batch_size:
+                    batch_processed = await process_documents_batch(batch, api_key, base_url, model, dry_run, collection, semaphore)
+                    processed += batch_processed
+                    batch = []
+                    
+                    if batch_size > 0 and processed % batch_size == 0:
+                        print(f"Processed {processed} documents...")
+            
+            # Process remaining documents in the last batch
+            if batch:
+                batch_processed = await process_documents_batch(batch, api_key, base_url, model, dry_run, collection, semaphore)
+                processed += batch_processed
+
+        finally:
+            cursor.close()
+
+        print(f"Done. Total processed: {processed}")
+    
+    # Run the async processing
+    asyncio.run(run_async_processing())
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description='Normalize MongoDB articles using an OpenAI-compatible API')
+    parser.add_argument('--env-file', type=str, default='normalize.env', help='Path to env file with configuration')
+    parser.add_argument('--limit', type=int, default=None, help='Limit number of documents to process')
+    parser.add_argument('--resume-from', type=str, default=None, help='Resume from a given ObjectId (exclusive)')
+    parser.add_argument('--batch-size', type=int, default=20, help='Progress print frequency')
+    parser.add_argument('--concurrency', type=int, default=5, help='Number of concurrent API calls')
+    parser.add_argument('--dry-run', action='store_true', help='Preview changes: print original and normalized text; no DB writes')
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+
+    # Load env file first, allowing it to supply all needed variables
+    if args.env_file:
+        load_env_file(args.env_file)
+
+    api_key = os.environ.get('OPENAI_API_KEY')
+    if not api_key:
+        print('Error: OPENAI_API_KEY is required in environment.')
+        sys.exit(1)
+
+    # Support OPENAI_API_URL as well as OPENAI_BASE_URL
+    base_url = os.environ.get('OPENAI_API_URL') or os.environ.get('OPENAI_BASE_URL')
+    model = os.environ.get('OPENAI_MODEL', 'gemini-flash-lite-latest')
+
+    collection = get_mongo_collection()
+    process_documents(
+        collection=collection,
+        limit=args.limit,
+        resume_from=args.resume_from,
+        batch_size=args.batch_size,
+        dry_run=args.dry_run,
+        api_key=api_key,
+        base_url=base_url,
+        model=model,
+        concurrency=args.concurrency,
+    )
+
+
+if __name__ == '__main__':
+    main()

scripts/normalize_jsonl.py

@@ -0,0 +1,311 @@
+#!/usr/bin/env python3
+"""
+Script to normalize JSONL entries for LLM fine-tuning.
+Filters out entries without text and normalizes content using OpenAI-compatible API.
+"""
+
+import json
+import logging
+import os
+import sys
+from pathlib import Path
+from typing import Dict, Any, Optional
+import time
+import argparse
+
+try:
+    import openai
+except ImportError:
+    print("Error: openai package not found. Install with: pip install openai")
+    sys.exit(1)
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('normalize_log.txt'),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+class JSONLNormalizer:
+    def __init__(self, api_key: str, base_url: str = None, model: str = "gpt-3.5-turbo"):
+        """
+        Initialize the normalizer with OpenAI-compatible API settings.
+        
+        Args:
+            api_key: API key for the service
+            base_url: Base URL for API (optional, defaults to OpenAI)
+            model: Model name to use for normalization
+        """
+        self.client = openai.OpenAI(
+            api_key=api_key,
+            base_url=base_url
+        )
+        self.model = model
+        self.processed_count = 0
+        self.skipped_count = 0
+        self.failed_count = 0
+        self.already_normalized_count = 0
+        
+    def normalize_text(self, text: str, title: str = "", subtitle: str = "") -> Optional[str]:
+        """
+        Normalize text content using the API.
+        
+        Args:
+            text: Main text content to normalize
+            title: Article title for context
+            subtitle: Article subtitle for context
+            
+        Returns:
+            Normalized text or None if normalization fails
+        """
+        try:
+            system_prompt = """You are an expert text editor helping to prepare content for LLM fine-tuning. 
+
+Your task is to normalize and clean text while preserving its meaning and literary quality. Make these improvements:
+
+1. Fix obvious typos and spelling errors
+2. Normalize punctuation and spacing inconsistencies
+3. Remove excessive whitespace and newlines (but preserve intentional line breaks for poetry/paragraphs)
+4. Ensure proper capitalization
+5. Fix encoding issues or strange characters
+6. Maintain the original style and voice
+7. Preserve intentional formatting (like poetry line breaks)
+8. Remove any metadata or non-content text
+
+Return ONLY the cleaned text, nothing else."""
+
+            user_prompt = f"""Title: {title}
+Subtitle: {subtitle}
+
+Text to normalize:
+{text}"""
+
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": user_prompt}
+                ],
+                temperature=0.1,
+                max_tokens=4000
+            )
+            
+            normalized_text = response.choices[0].message.content.strip()
+            return normalized_text
+            
+        except Exception as e:
+            logger.error(f"API normalization failed: {str(e)}")
+            return None
+    
+    def is_valid_entry(self, entry: Dict[Any, Any]) -> bool:
+        """
+        Check if entry has valid text content.
+        
+        Args:
+            entry: JSONL entry dictionary
+            
+        Returns:
+            True if entry has non-empty text field
+        """
+        text = entry.get('text', '')
+        return isinstance(text, str) and text.strip() != ''
+    
+    def is_already_normalized(self, entry: Dict[Any, Any]) -> bool:
+        """
+        Check if entry has already been normalized.
+        
+        Args:
+            entry: JSONL entry dictionary
+            
+        Returns:
+            True if entry has already been normalized
+        """
+        return entry.get('_normalized', False) or entry.get('_normalization_failed', False)
+    
+    def process_jsonl(self, input_file: str, output_file: str, failed_file: str, 
+                     max_entries: Optional[int] = None, delay: float = 0.5, 
+                     force_reprocess: bool = False, append: bool = False):
+        """
+        Process the JSONL file and normalize entries.
+        
+        Args:
+            input_file: Path to input JSONL file
+            output_file: Path to output normalized JSONL file
+            failed_file: Path to file for failed normalizations
+            max_entries: Maximum number of entries to process (for testing)
+            delay: Delay between API calls to avoid rate limits
+            force_reprocess: If True, reprocess already normalized entries
+            append: If True, append to existing output files instead of overwriting them
+        """
+        logger.info(f"Starting normalization of {input_file}")
+        logger.info(f"Output file: {output_file} (mode: {'append' if append else 'overwrite'})")
+        logger.info(f"Failed entries file: {failed_file} (mode: {'append' if append else 'overwrite'})")
+        if force_reprocess:
+            logger.info("Force reprocess enabled - will reprocess already normalized entries")
+        
+        # Determine file modes based on append flag
+        output_mode = 'a' if append else 'w'
+        failed_mode = 'a' if append else 'w'
+        
+        with open(input_file, 'r', encoding='utf-8') as infile, \
+             open(output_file, output_mode, encoding='utf-8') as outfile, \
+             open(failed_file, failed_mode, encoding='utf-8') as failfile:
+            
+            for line_num, line in enumerate(infile, 1):
+                try:
+                    # Parse JSON line
+                    entry = json.loads(line.strip())
+                    
+                    # Skip entries without valid text
+                    if not self.is_valid_entry(entry):
+                        logger.debug(f"Line {line_num}: Skipping entry without text")
+                        self.skipped_count += 1
+                        continue
+                    
+                    # Check if already normalized or failed (unless forcing reprocess)
+                    if not force_reprocess and self.is_already_normalized(entry):
+                        title = entry.get('title', '')
+                        logger.debug(f"Line {line_num}: Entry '{title[:50]}...' already processed")
+                        
+                        # Write to appropriate file based on previous result
+                        if entry.get('_normalized', False):
+                            outfile.write(json.dumps(entry, ensure_ascii=False) + '\n')
+                        elif entry.get('_normalization_failed', False):
+                            failfile.write(json.dumps(entry, ensure_ascii=False) + '\n')
+                        
+                        self.already_normalized_count += 1
+                        
+                        # Check max_entries limit after counting already normalized entries
+                        if max_entries and (self.processed_count + self.already_normalized_count) >= max_entries:
+                            logger.info(f"Reached maximum entries limit: {max_entries}")
+                            break
+                        continue
+                    
+                    # Check max_entries limit before processing new entries
+                    if max_entries and (self.processed_count + self.already_normalized_count) >= max_entries:
+                        logger.info(f"Reached maximum entries limit: {max_entries}")
+                        break
+                    
+                    # Extract content for normalization
+                    original_text = entry['text']
+                    title = entry.get('title', '')
+                    subtitle = entry.get('subtitle', '')
+                    
+                    logger.info(f"Line {line_num}: Normalizing entry '{title[:50]}...'")
+                    
+                    # Normalize the text
+                    normalized_text = self.normalize_text(original_text, title, subtitle)
+                    
+                    if normalized_text:
+                        # Update entry with normalized text
+                        entry['text'] = normalized_text
+                        entry['_original_length'] = len(original_text)
+                        entry['_normalized_length'] = len(normalized_text)
+                        entry['_normalized'] = True
+                        
+                        # Write to output file
+                        outfile.write(json.dumps(entry, ensure_ascii=False) + '\n')
+                        self.processed_count += 1
+                        logger.info(f"Line {line_num}: Successfully normalized")
+                    else:
+                        # Write failed entry to failed file
+                        entry['_normalization_failed'] = True
+                        failfile.write(json.dumps(entry, ensure_ascii=False) + '\n')
+                        self.failed_count += 1
+                        logger.warning(f"Line {line_num}: Normalization failed")
+                    
+                    # Rate limiting delay (only for new API calls)
+                    if delay > 0:
+                        time.sleep(delay)
+                        
+                except json.JSONDecodeError as e:
+                    logger.error(f"Line {line_num}: JSON decode error: {str(e)}")
+                    self.failed_count += 1
+                except Exception as e:
+                    logger.error(f"Line {line_num}: Unexpected error: {str(e)}")
+                    self.failed_count += 1
+                    
+                # Progress update
+                if line_num % 10 == 0:
+                    total_processed = self.processed_count + self.already_normalized_count
+                    logger.info(f"Progress: Processed {line_num} lines, "
+                              f"Total processed: {total_processed}, "
+                              f"Newly normalized: {self.processed_count}, "
+                              f"Already processed: {self.already_normalized_count}, "
+                              f"Skipped: {self.skipped_count}, "
+                              f"Failed: {self.failed_count}")
+        
+        # Final summary
+        total_processed = self.processed_count + self.already_normalized_count
+        logger.info("=" * 50)
+        logger.info("NORMALIZATION COMPLETE")
+        logger.info(f"Total lines processed: {line_num}")
+        logger.info(f"Total entries processed: {total_processed}")
+        logger.info(f"Newly normalized: {self.processed_count}")
+        logger.info(f"Already processed (skipped): {self.already_normalized_count}")
+        logger.info(f"Skipped (no text): {self.skipped_count}")
+        logger.info(f"Failed: {self.failed_count}")
+        logger.info("=" * 50)
+
+def main():
+    parser = argparse.ArgumentParser(description='Normalize JSONL entries for LLM fine-tuning')
+    parser.add_argument('input_file', help='Input JSONL file path')
+    parser.add_argument('-o', '--output', default='normalized_entries.jsonl', 
+                       help='Output file for normalized entries (default: normalized_entries.jsonl)')
+    parser.add_argument('-f', '--failed', default='failed_normalizations.jsonl',
+                       help='Output file for failed entries (default: failed_normalizations.jsonl)')
+    parser.add_argument('-k', '--api-key', help='OpenAI API key (or set OPENAI_API_KEY env var)')
+    parser.add_argument('-u', '--base-url', help='Base URL for OpenAI-compatible API')
+    parser.add_argument('-m', '--model', default='gpt-3.5-turbo', 
+                       help='Model to use (default: gpt-3.5-turbo)')
+    parser.add_argument('--max-entries', type=int, help='Maximum entries to process (for testing)')
+    parser.add_argument('--delay', type=float, default=0.5, 
+                       help='Delay between API calls in seconds (default: 0.5)')
+    parser.add_argument('--force-reprocess', action='store_true',
+                       help='Force reprocessing of already normalized entries')
+    parser.add_argument('--append', action='store_true',
+                       help='Append to existing output files instead of overwriting them')
+    
+    args = parser.parse_args()
+    
+    # Get API key
+    api_key = args.api_key or os.getenv('OPENAI_API_KEY')
+    if not api_key:
+        logger.error("API key required. Use --api-key or set OPENAI_API_KEY environment variable")
+        sys.exit(1)
+    
+    # Check input file exists
+    if not Path(args.input_file).exists():
+        logger.error(f"Input file not found: {args.input_file}")
+        sys.exit(1)
+    
+    # Initialize normalizer
+    normalizer = JSONLNormalizer(
+        api_key=api_key,
+        base_url=args.base_url,
+        model=args.model
+    )
+    
+    # Process the file
+    try:
+        normalizer.process_jsonl(
+            input_file=args.input_file,
+            output_file=args.output,
+            failed_file=args.failed,
+            max_entries=args.max_entries,
+            delay=args.delay,
+            force_reprocess=args.force_reprocess,
+            append=args.append
+        )
+    except KeyboardInterrupt:
+        logger.info("Process interrupted by user")
+    except Exception as e:
+        logger.error(f"Process failed: {str(e)}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main() 

scripts/requirements.txt

@@ -0,0 +1,5 @@
+pymongo
+aiohttp
+requests
+
+

stern_neon_user_poetry.jsonl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:fbbb7e4eb9229ec2864f9a32aa95a370a7c3b7ac1b46f565df55d598af7fdc87
-size 78398883
+oid sha256:db8bc2adbb7c9d94e042586ee1367390b52bfcf358d427701ba5150b90b4984a
+size 71686011