wisent 0.5.12__py3-none-any.whl → 0.5.14__py3-none-any.whl

wisent/core/cli/generate_pairs.py

@@ -0,0 +1,128 @@
+"""Generate pairs command execution logic - synthetic generation."""
+
+import sys
+import json
+import os
+
+
+def execute_generate_pairs(args):
+    """Execute the generate-pairs command - generate synthetic contrastive pairs from trait description."""
+    from wisent.core.models.wisent_model import WisentModel
+    from wisent.core.synthetic.generators.pairs_generator import SyntheticContrastivePairsGenerator
+    from wisent.core.synthetic.db_instructions.mini_dp import Default_DB_Instructions
+    from wisent.core.synthetic.cleaners.pairs_cleaner import PairsCleaner
+    from wisent.core.synthetic.cleaners.refusaler_cleaner import RefusalerCleaner
+    from wisent.core.synthetic.cleaners.deduper_cleaner import DeduperCleaner
+    from wisent.core.synthetic.generators.diversities.methods.fast_diversity import FastDiversity
+
+    print(f"\n🎨 Generating synthetic contrastive pairs")
+    print(f"   Trait: {args.trait}")
+    print(f"   Number of pairs: {args.num_pairs}")
+    print(f"   Model: {args.model}")
+
+    try:
+        # 1. Load model
+        print(f"\n🤖 Loading model '{args.model}'...")
+        model = WisentModel(args.model, device=args.device)
+        print(f"   ✓ Model loaded with {model.num_layers} layers")
+
+        # 2. Set up generation config
+        # Scale max_new_tokens based on number of pairs (roughly 150 tokens per pair + buffer)
+        estimated_tokens = args.num_pairs * 150 + 500
+        max_tokens = max(2048, min(estimated_tokens, 8192))  # Between 2048 and 8192
+
+        generation_config = {
+            "max_new_tokens": max_tokens,
+            "temperature": 0.9,
+            "do_sample": True,
+        }
+
+        # 3. Set up cleaning pipeline
+        print(f"\n🧹 Setting up cleaning pipeline...")
+        from wisent.core.synthetic.cleaners.methods.base_dedupers import SimHashDeduper
+
+        cleaning_steps = [
+            DeduperCleaner(deduper=SimHashDeduper(threshold_bits=3)),
+        ]
+        cleaner = PairsCleaner(steps=cleaning_steps)
+
+        # 4. Set up components
+        db_instructions = Default_DB_Instructions()
+        diversity = FastDiversity()
+
+        # 5. Create generator
+        print(f"\n⚙️  Initializing generator...")
+        generator = SyntheticContrastivePairsGenerator(
+            model=model,
+            generation_config=generation_config,
+            contrastive_set_name=f"synthetic_{args.trait[:20].replace(' ', '_')}",
+            trait_description=args.trait,
+            trait_label=args.trait[:50],
+            db_instructions=db_instructions,
+            cleaner=cleaner,
+            diversity=diversity,
+        )
+
+        # 6. Generate pairs
+        print(f"\n🎯 Generating {args.num_pairs} contrastive pairs...")
+        if args.timing:
+            import time
+            start_time = time.time()
+
+        pair_set, report = generator.generate(num_pairs=args.num_pairs)
+
+        if args.timing:
+            elapsed = time.time() - start_time
+            print(f"   ⏱️  Generation time: {elapsed:.2f}s")
+
+        print(f"   ✓ Generated {len(pair_set.pairs)} pairs")
+
+        # 7. Print generation report
+        if args.verbose and len(pair_set.pairs) > 0:
+            print(f"\n📊 Generation Report:")
+            print(f"   Requested: {report.requested}")
+            print(f"   Kept after dedupe: {report.kept_after_dedupe}")
+            print(f"   Retries for refusals: {report.retries_for_refusals}")
+            if report.diversity:
+                print(f"   Diversity:")
+                print(f"     • Unique unigrams: {report.diversity.unique_unigrams:.3f}")
+                print(f"     • Unique bigrams: {report.diversity.unique_bigrams:.3f}")
+                print(f"     • Avg Jaccard: {report.diversity.avg_jaccard_prompt:.3f}")
+
+        # 8. Convert pairs to dict format for JSON serialization
+        print(f"\n💾 Saving pairs to '{args.output}'...")
+        pairs_data = []
+        for pair in pair_set.pairs:
+            pair_dict = pair.to_dict()
+            pairs_data.append(pair_dict)
+
+        # 9. Save to JSON file
+        os.makedirs(os.path.dirname(os.path.abspath(args.output)), exist_ok=True)
+        save_data = {
+            'trait_description': args.trait,
+            'trait_label': pair_set.task_type,
+            'num_pairs': len(pairs_data),
+            'generation_config': generation_config,
+            'requested': report.requested,
+            'kept_after_dedupe': report.kept_after_dedupe,
+            'pairs': pairs_data
+        }
+        if report.diversity:
+            save_data['diversity'] = {
+                'unique_unigrams': report.diversity.unique_unigrams,
+                'unique_bigrams': report.diversity.unique_bigrams,
+                'avg_jaccard': report.diversity.avg_jaccard_prompt
+            }
+
+        with open(args.output, 'w') as f:
+            json.dump(save_data, f, indent=2)
+
+        print(f"   ✓ Saved {len(pairs_data)} pairs to: {args.output}")
+        print(f"\n✅ Synthetic pair generation completed successfully!\n")
+
+    except Exception as e:
+        print(f"\n❌ Error: {str(e)}", file=sys.stderr)
+        if args.verbose:
+            import traceback
+            traceback.print_exc()
+        sys.exit(1)

wisent/core/cli/generate_pairs_from_task.py

@@ -0,0 +1,119 @@
+"""Generate pairs from task command execution logic."""
+
+import sys
+import json
+import os
+
+
+def _load_custom_task(task_name: str, limit: int | None):
+    """Load custom tasks that aren't in lm-eval."""
+    if task_name == "livecodebench":
+        from wisent.core.tasks.livecodebench_task import LiveCodeBenchTask
+        return LiveCodeBenchTask(release_version="release_v1", limit=limit)
+    else:
+        raise ValueError(
+            f"Task '{task_name}' not found in lm-eval or custom tasks. "
+            f"Available custom tasks: livecodebench"
+        )
+
+
+def _build_pairs_from_custom_task(task, limit: int | None):
+    """Build contrastive pairs from custom TaskInterface tasks."""
+    from wisent.core.contrastive_pairs.lm_eval_pairs.lm_task_extractors.livecodebench import (
+        LiveCodeBenchExtractor as LiveCodeBenchPairExtractor
+    )
+
+    task_name = task.get_name()
+
+    if task_name == "livecodebench":
+        # Use the contrastive pair extractor for LiveCodeBench
+        extractor = LiveCodeBenchPairExtractor()
+        # Extract pairs using the task's test_docs interface
+        return extractor.extract_contrastive_pairs(task, limit=limit)
+    else:
+        raise ValueError(f"No contrastive pair extractor configured for custom task: {task_name}")
+
+
+def execute_generate_pairs_from_task(args):
+    """Execute the generate-pairs-from-task command - load and save contrastive pairs from a task."""
+    from wisent.core.data_loaders.loaders.lm_loader import LMEvalDataLoader
+
+    print(f"\n📊 Generating contrastive pairs from task: {args.task_name}")
+
+    if args.limit:
+        print(f"   Limit: {args.limit} pairs")
+
+    try:
+        # 1. Load task data using LMEvalDataLoader
+        print(f"\n🔄 Loading task '{args.task_name}'...")
+
+        # Try to load from lm-eval first
+        loader = LMEvalDataLoader()
+        try:
+            # Use load_lm_eval_task to get the task object
+            task_obj = loader.load_lm_eval_task(args.task_name)
+        except KeyError:
+            # Task not in lm-eval, try our custom tasks
+            print(f"   ℹ️  Task not found in lm-eval, trying custom tasks...")
+            task_obj = _load_custom_task(args.task_name, args.limit)
+
+        # Import the pair generation function
+        from wisent.core.contrastive_pairs.lm_eval_pairs.lm_task_pairs_generation import (
+            lm_build_contrastive_pairs,
+        )
+
+        # Handle both lm-eval tasks (dict) and custom tasks (TaskInterface)
+        if isinstance(task_obj, dict):
+            # lm-eval task
+            if len(task_obj) != 1:
+                keys = ", ".join(sorted(task_obj.keys()))
+                raise ValueError(
+                    f"Task '{args.task_name}' returned {len(task_obj)} subtasks ({keys}). "
+                    "Specify an explicit subtask, e.g. 'benchmark/subtask'."
+                )
+            (subname, task), = task_obj.items()
+            pairs_task_name = subname
+
+            # 2. Generate contrastive pairs using lm-eval interface
+            print(f"   🔨 Building contrastive pairs...")
+            pairs = lm_build_contrastive_pairs(
+                task_name=pairs_task_name,
+                lm_eval_task=task,
+                limit=args.limit,
+            )
+        else:
+            # Custom task (TaskInterface)
+            task = task_obj
+            pairs_task_name = args.task_name
+
+            # 2. Generate contrastive pairs using custom task interface
+            print(f"   🔨 Building contrastive pairs...")
+            pairs = _build_pairs_from_custom_task(task, args.limit)
+
+        print(f"   ✓ Generated {len(pairs)} contrastive pairs")
+
+        # 3. Convert pairs to dict format for JSON serialization
+        print(f"\n💾 Saving pairs to '{args.output}'...")
+        pairs_data = []
+        for pair in pairs:
+            pair_dict = pair.to_dict()
+            pairs_data.append(pair_dict)
+
+        # 4. Save to JSON file
+        os.makedirs(os.path.dirname(os.path.abspath(args.output)), exist_ok=True)
+        with open(args.output, 'w') as f:
+            json.dump({
+                'task_name': pairs_task_name,
+                'num_pairs': len(pairs),
+                'pairs': pairs_data
+            }, f, indent=2)
+
+        print(f"   ✓ Saved {len(pairs)} pairs to: {args.output}")
+        print(f"\n✅ Contrastive pairs generation completed successfully!\n")
+
+    except Exception as e:
+        print(f"\n❌ Error: {str(e)}", file=sys.stderr)
+        if args.verbose:
+            import traceback
+            traceback.print_exc()
+        sys.exit(1)

wisent/core/cli/generate_responses.py

@@ -0,0 +1,129 @@
+"""Generate responses command execution logic."""
+
+import json
+import os
+import sys
+
+
+def execute_generate_responses(args):
+    """
+    Execute the generate-responses command.
+
+    Generates model responses to questions from a task and saves them to a file.
+    """
+    from wisent.core.models.wisent_model import WisentModel
+    from wisent.core.data_loaders.loaders.lm_loader import LMEvalDataLoader
+
+    print(f"\n{'='*80}")
+    print(f"🎯 GENERATING RESPONSES FROM TASK")
+    print(f"{'='*80}")
+    print(f"   Task: {args.task}")
+    print(f"   Model: {args.model}")
+    print(f"   Num questions: {args.num_questions}")
+    print(f"   Device: {args.device or 'auto'}")
+    print(f"{'='*80}\n")
+
+    # Load model
+    print(f"📦 Loading model...")
+    model = WisentModel(args.model, device=args.device)
+    print(f"   ✓ Model loaded\n")
+
+    # Load task data
+    print(f"📊 Loading task data...")
+    loader = LMEvalDataLoader()
+    try:
+        result = loader._load_one_task(
+            task_name=args.task,
+            split_ratio=0.8,
+            seed=42,
+            limit=args.num_questions,
+            training_limit=None,
+            testing_limit=None
+        )
+
+        # Use test pairs for generation
+        pairs = result['test_qa_pairs'].pairs[:args.num_questions]
+        print(f"   ✓ Loaded {len(pairs)} question pairs\n")
+
+    except Exception as e:
+        print(f"   ❌ Failed to load task: {e}")
+        sys.exit(1)
+
+    # Generate responses
+    print(f"🤖 Generating responses...\n")
+    results = []
+
+    for idx, pair in enumerate(pairs, 1):
+        if args.verbose:
+            print(f"Question {idx}/{len(pairs)}:")
+            print(f"   Prompt: {pair.prompt[:100]}...")
+
+        try:
+            # Convert prompt to chat format
+            messages = [
+                {"role": "user", "content": pair.prompt}
+            ]
+
+            # Generate response
+            responses = model.generate(
+                inputs=[messages],
+                max_new_tokens=args.max_new_tokens,
+                temperature=args.temperature,
+                top_p=args.top_p,
+                do_sample=True,
+                use_steering=args.use_steering,
+            )
+
+            generated_text = responses[0] if responses else ""
+
+            if args.verbose:
+                print(f"   Generated: {generated_text[:100]}...")
+                print()
+
+            results.append({
+                "question_id": idx,
+                "prompt": pair.prompt,
+                "generated_response": generated_text,
+                "positive_reference": pair.positive_response.model_response,
+                "negative_reference": pair.negative_response.model_response
+            })
+
+        except Exception as e:
+            print(f"   ❌ Error generating response for question {idx}: {e}")
+            results.append({
+                "question_id": idx,
+                "prompt": pair.prompt,
+                "generated_response": None,
+                "error": str(e)
+            })
+
+    # Save results
+    print(f"\n💾 Saving results...")
+    os.makedirs(os.path.dirname(args.output), exist_ok=True)
+
+    output_data = {
+        "task": args.task,
+        "model": args.model,
+        "num_questions": len(pairs),
+        "generation_params": {
+            "max_new_tokens": args.max_new_tokens,
+            "temperature": args.temperature,
+            "top_p": args.top_p,
+            "use_steering": args.use_steering
+        },
+        "responses": results
+    }
+
+    with open(args.output, 'w') as f:
+        json.dump(output_data, f, indent=2)
+
+    print(f"   ✓ Results saved to: {args.output}\n")
+
+    # Print summary
+    print(f"{'='*80}")
+    print(f"✅ GENERATION COMPLETE")
+    print(f"{'='*80}")
+    print(f"   Total questions: {len(results)}")
+    print(f"   Successful: {sum(1 for r in results if 'error' not in r)}")
+    print(f"   Failed: {sum(1 for r in results if 'error' in r)}")
+    print(f"{'='*80}\n")

wisent/core/cli/generate_vector_from_synthetic.py

@@ -0,0 +1,149 @@
+"""Generate steering vector from synthetic pairs command execution logic - unified pipeline."""
+
+import sys
+import os
+import time
+import tempfile
+from argparse import Namespace
+
+from wisent.core.cli.generate_pairs import execute_generate_pairs
+from wisent.core.cli.get_activations import execute_get_activations
+from wisent.core.cli.create_steering_vector import execute_create_steering_vector
+
+
+def execute_generate_vector_from_synthetic(args):
+    """
+    Execute the generate-vector-from-synthetic command - full pipeline in one command.
+    
+    Pipeline:
+    1. Generate synthetic contrastive pairs for a trait
+    2. Collect activations from those pairs
+    3. Create steering vectors from the activations
+    """
+    print(f"\n{'='*60}")
+    print(f"🎯 Generating Steering Vector from Synthetic Pairs (Full Pipeline)")
+    print(f"{'='*60}")
+    print(f"   Trait: {args.trait}")
+    print(f"   Model: {args.model}")
+    print(f"   Num Pairs: {args.num_pairs}")
+    print(f"{'='*60}\n")
+    
+    pipeline_start = time.time() if args.timing else None
+    
+    try:
+        # Determine intermediate file paths
+        if args.intermediate_dir:
+            intermediate_dir = args.intermediate_dir
+        else:
+            intermediate_dir = os.path.dirname(os.path.abspath(args.output))
+        
+        os.makedirs(intermediate_dir, exist_ok=True)
+        
+        # Create intermediate file paths
+        if args.keep_intermediate:
+            pairs_file = os.path.join(intermediate_dir, f"{args.trait.replace(' ', '_')}_pairs.json")
+            enriched_file = os.path.join(intermediate_dir, f"{args.trait.replace(' ', '_')}_pairs_with_activations.json")
+        else:
+            # Use temporary files that will be deleted
+            pairs_file = tempfile.NamedTemporaryFile(mode='w', suffix='_pairs.json', delete=False).name
+            enriched_file = tempfile.NamedTemporaryFile(mode='w', suffix='_enriched.json', delete=False).name
+
+        # Step 1: Generate synthetic pairs
+        print(f"{'='*60}")
+        print(f"Step 1/3: Generating synthetic contrastive pairs...")
+        print(f"{'='*60}\n")
+        
+        pairs_args = Namespace(
+            trait=args.trait,
+            num_pairs=args.num_pairs,
+            output=pairs_file,
+            model=args.model,
+            device=args.device,
+            similarity_threshold=args.similarity_threshold,
+            verbose=args.verbose,
+            timing=args.timing,
+        )
+        
+        execute_generate_pairs(pairs_args)
+        print(f"\n✓ Step 1 complete: Pairs saved to {pairs_file}\n")
+        
+        # Step 2: Collect activations
+        print(f"{'='*60}")
+        print(f"Step 2/3: Collecting activations from pairs...")
+        print(f"{'='*60}\n")
+        
+        activations_args = Namespace(
+            pairs_file=pairs_file,
+            output=enriched_file,
+            model=args.model,
+            device=args.device,
+            layers=args.layers,
+            token_aggregation=args.token_aggregation,
+            prompt_strategy=args.prompt_strategy,
+            verbose=args.verbose,
+            timing=args.timing,
+        )
+        
+        execute_get_activations(activations_args)
+        print(f"\n✓ Step 2 complete: Enriched pairs saved to {enriched_file}\n")
+        
+        # Step 3: Create steering vector
+        print(f"{'='*60}")
+        print(f"Step 3/3: Creating steering vector...")
+        print(f"{'='*60}\n")
+        
+        vector_args = Namespace(
+            enriched_pairs_file=enriched_file,
+            output=args.output,
+            method=args.method,
+            normalize=args.normalize,
+            verbose=args.verbose,
+            timing=args.timing,
+        )
+        
+        execute_create_steering_vector(vector_args)
+        print(f"\n✓ Step 3 complete: Steering vector saved to {args.output}\n")
+        
+        # Clean up intermediate files if not keeping them
+        if not args.keep_intermediate:
+            if args.verbose:
+                print(f"\n🧹 Cleaning up intermediate files...")
+            try:
+                os.unlink(pairs_file)
+                os.unlink(enriched_file)
+                if args.verbose:
+                    print(f"   ✓ Removed temporary files")
+            except Exception as e:
+                if args.verbose:
+                    print(f"   ⚠️  Warning: Could not remove some temporary files: {e}")
+        
+        # Final summary
+        print(f"\n{'='*60}")
+        print(f"✅ Full Pipeline Completed Successfully!")
+        print(f"{'='*60}")
+        print(f"   Final steering vector: {args.output}")
+        if args.keep_intermediate:
+            print(f"   Intermediate pairs: {pairs_file}")
+            print(f"   Intermediate enriched: {enriched_file}")
+        if args.timing and pipeline_start:
+            total_time = time.time() - pipeline_start
+            print(f"   ⏱️  Total pipeline time: {total_time:.2f}s")
+        print(f"{'='*60}\n")
+        
+    except Exception as e:
+        print(f"\n❌ Pipeline failed: {str(e)}", file=sys.stderr)
+        if args.verbose:
+            import traceback
+            traceback.print_exc()
+        
+        # Clean up on failure
+        if not args.keep_intermediate:
+            try:
+                if 'pairs_file' in locals() and os.path.exists(pairs_file):
+                    os.unlink(pairs_file)
+                if 'enriched_file' in locals() and os.path.exists(enriched_file):
+                    os.unlink(enriched_file)
+            except:
+                pass
+        
+        sys.exit(1)

wisent/core/cli/generate_vector_from_task.py

@@ -0,0 +1,147 @@
+"""Generate steering vector from task command execution logic - unified pipeline."""
+
+import sys
+import os
+import time
+import tempfile
+from argparse import Namespace
+
+from wisent.core.cli.generate_pairs_from_task import execute_generate_pairs_from_task
+from wisent.core.cli.get_activations import execute_get_activations
+from wisent.core.cli.create_steering_vector import execute_create_steering_vector
+
+
+def execute_generate_vector_from_task(args):
+    """
+    Execute the generate-vector-from-task command - full pipeline in one command.
+    
+    Pipeline:
+    1. Generate contrastive pairs from lm-eval task
+    2. Collect activations from those pairs
+    3. Create steering vectors from the activations
+    """
+    print(f"\n{'='*60}")
+    print(f"🎯 Generating Steering Vector from Task (Full Pipeline)")
+    print(f"{'='*60}")
+    print(f"   Task: {args.task}")
+    print(f"   Trait Label: {args.trait_label}")
+    print(f"   Model: {args.model}")
+    print(f"   Num Pairs: {args.num_pairs}")
+    print(f"{'='*60}\n")
+    
+    pipeline_start = time.time() if args.timing else None
+    
+    try:
+        # Determine intermediate file paths
+        if args.intermediate_dir:
+            intermediate_dir = args.intermediate_dir
+        else:
+            intermediate_dir = os.path.dirname(os.path.abspath(args.output))
+        
+        os.makedirs(intermediate_dir, exist_ok=True)
+        
+        # Create intermediate file paths
+        if args.keep_intermediate:
+            pairs_file = os.path.join(intermediate_dir, f"{args.task}_{args.trait_label}_pairs.json")
+            enriched_file = os.path.join(intermediate_dir, f"{args.task}_{args.trait_label}_pairs_with_activations.json")
+        else:
+            # Use temporary files that will be deleted
+            pairs_file = tempfile.NamedTemporaryFile(mode='w', suffix='_pairs.json', delete=False).name
+            enriched_file = tempfile.NamedTemporaryFile(mode='w', suffix='_enriched.json', delete=False).name
+
+        # Step 1: Generate pairs from task
+        print(f"{'='*60}")
+        print(f"Step 1/3: Generating contrastive pairs from task...")
+        print(f"{'='*60}\n")
+        
+        pairs_args = Namespace(
+            task_name=args.task,
+            limit=args.num_pairs,
+            output=pairs_file,
+            seed=42,
+            verbose=args.verbose,
+        )
+        
+        execute_generate_pairs_from_task(pairs_args)
+        print(f"\n✓ Step 1 complete: Pairs saved to {pairs_file}\n")
+        
+        # Step 2: Collect activations
+        print(f"{'='*60}")
+        print(f"Step 2/3: Collecting activations from pairs...")
+        print(f"{'='*60}\n")
+        
+        activations_args = Namespace(
+            pairs_file=pairs_file,
+            output=enriched_file,
+            model=args.model,
+            device=args.device,
+            layers=args.layers,
+            token_aggregation=args.token_aggregation,
+            prompt_strategy=args.prompt_strategy,
+            verbose=args.verbose,
+            timing=args.timing,
+        )
+        
+        execute_get_activations(activations_args)
+        print(f"\n✓ Step 2 complete: Enriched pairs saved to {enriched_file}\n")
+        
+        # Step 3: Create steering vector
+        print(f"{'='*60}")
+        print(f"Step 3/3: Creating steering vector...")
+        print(f"{'='*60}\n")
+        
+        vector_args = Namespace(
+            enriched_pairs_file=enriched_file,
+            output=args.output,
+            method=args.method,
+            normalize=args.normalize,
+            verbose=args.verbose,
+            timing=args.timing,
+        )
+        
+        execute_create_steering_vector(vector_args)
+        print(f"\n✓ Step 3 complete: Steering vector saved to {args.output}\n")
+        
+        # Clean up intermediate files if not keeping them
+        if not args.keep_intermediate:
+            if args.verbose:
+                print(f"\n🧹 Cleaning up intermediate files...")
+            try:
+                os.unlink(pairs_file)
+                os.unlink(enriched_file)
+                if args.verbose:
+                    print(f"   ✓ Removed temporary files")
+            except Exception as e:
+                if args.verbose:
+                    print(f"   ⚠️  Warning: Could not remove some temporary files: {e}")
+        
+        # Final summary
+        print(f"\n{'='*60}")
+        print(f"✅ Full Pipeline Completed Successfully!")
+        print(f"{'='*60}")
+        print(f"   Final steering vector: {args.output}")
+        if args.keep_intermediate:
+            print(f"   Intermediate pairs: {pairs_file}")
+            print(f"   Intermediate enriched: {enriched_file}")
+        if args.timing and pipeline_start:
+            total_time = time.time() - pipeline_start
+            print(f"   ⏱️  Total pipeline time: {total_time:.2f}s")
+        print(f"{'='*60}\n")
+        
+    except Exception as e:
+        print(f"\n❌ Pipeline failed: {str(e)}", file=sys.stderr)
+        if args.verbose:
+            import traceback
+            traceback.print_exc()
+        
+        # Clean up on failure
+        if not args.keep_intermediate:
+            try:
+                if 'pairs_file' in locals() and os.path.exists(pairs_file):
+                    os.unlink(pairs_file)
+                if 'enriched_file' in locals() and os.path.exists(enriched_file):
+                    os.unlink(enriched_file)
+            except:
+                pass
+        
+        sys.exit(1)