package_validator.py

#!/usr/bin/env python3
"""
Package Existence Checker
Validates if packages mentioned in code are real packages that exist in package repositories
"""

import requests
import re
import json
import time
from typing import List, Dict, Tuple, Set
import argparse
from urllib.parse import quote
import sys

class PackageValidator:
    def __init__(self):
        self.pypi_base_url = "https://pypi.org/pypi"
        self.npm_base_url = "https://registry.npmjs.org"
        self.headers = {
            'User-Agent': 'PackageValidator/1.0'
        }
        # Cache to avoid redundant API calls
        self.cache = {}
        
        # Known fake/made-up packages in tutorials
        self.known_fake_packages = {
            'example-package', 'test-package', 'dummy-package', 'my-package',
            'awesome-library', 'cool-tool', 'sample-module', 'placeholder',
            'fakepackage', 'mocklib', 'dummylib', 'examplelib'
        }
        
        # Common patterns for fake packages
        self.fake_patterns = [
            r'^[Mm]y[-_].*',
            r'^[Ee]xample[-_].*',
            r'^[Tt]est[-_].*',
            r'^[Dd]emo[-_].*',
            r'^[Ff]ake[-_].*',
            r'^[Mm]ock[-_].*',
            r'^[Dd]ummy[-_].*',
            r'.*[-_]example$',
            r'.*[-_]demo$',
            r'.*[-_]test$',
        ]

    def check_pypi(self, package_name: str) -> Tuple[bool, Dict]:
        """Check if package exists on PyPI"""
        if package_name in self.cache:
            return self.cache[package_name]
        
        url = f"{self.pypi_base_url}/{package_name}/json"
        
        try:
            response = requests.get(url, headers=self.headers, timeout=10)
            
            if response.status_code == 200:
                data = response.json()
                result = (True, {
                    'exists': True,
                    'name': data.get('info', {}).get('name'),
                    'version': data.get('info', {}).get('version'),
                    'summary': data.get('info', {}).get('summary', ''),
                    'home_page': data.get('info', {}).get('home_page', ''),
                    'downloads': data.get('info', {}).get('downloads', {}),
                    'last_serial': data.get('last_serial', 0)
                })
            elif response.status_code == 404:
                result = (False, {'exists': False, 'error': 'Package not found on PyPI'})
            else:
                result = (False, {'exists': False, 'error': f'HTTP {response.status_code}'})
                
        except requests.RequestException as e:
            result = (False, {'exists': False, 'error': str(e)})
        
        self.cache[package_name] = result
        return result

    def check_npm(self, package_name: str) -> Tuple[bool, Dict]:
        """Check if package exists on npm"""
        url = f"{self.npm_base_url}/{package_name}"
        
        try:
            response = requests.get(url, headers=self.headers, timeout=10)
            
            if response.status_code == 200:
                data = response.json()
                result = (True, {
                    'exists': True,
                    'name': data.get('name'),
                    'version': data.get('dist-tags', {}).get('latest'),
                    'description': data.get('description', ''),
                    'homepage': data.get('homepage', ''),
                    'repository': data.get('repository', {})
                })
            elif response.status_code == 404:
                result = (False, {'exists': False, 'error': 'Package not found on npm'})
            else:
                result = (False, {'exists': False, 'error': f'HTTP {response.status_code}'})
                
        except requests.RequestException as e:
            result = (False, {'exists': False, 'error': str(e)})
        
        return result

    def search_package(self, package_name: str, repository: str = 'pypi') -> Dict:
        """
        Search for package across repositories
        Returns comprehensive information about package existence
        """
        result = {
            'package': package_name,
            'repository': repository,
            'exists': False,
            'is_fake_likely': False,
            'fake_reason': '',
            'details': {}
        }
        
        # Check if package name looks fake
        fake_assessment = self.assess_if_fake(package_name)
        if fake_assessment['is_fake']:
            result['is_fake_likely'] = True
            result['fake_reason'] = fake_assessment['reason']
            return result
        
        # Check actual repository
        if repository.lower() == 'pypi':
            exists, details = self.check_pypi(package_name)
            result['exists'] = exists
            result['details'] = details
        elif repository.lower() == 'npm':
            exists, details = self.check_npm(package_name)
            result['exists'] = exists
            result['details'] = details
        else:
            result['details'] = {'error': f'Unsupported repository: {repository}'}
        
        return result

    def assess_if_fake(self, package_name: str) -> Dict:
        """Assess if a package name looks fake/made-up"""
        lower_name = package_name.lower()
        
        # Check against known fake packages
        if lower_name in self.known_fake_packages:
            return {'is_fake': True, 'reason': 'Known fake package name'}
        
        # Check patterns
        for pattern in self.fake_patterns:
            if re.match(pattern, package_name):
                return {'is_fake': True, 'reason': f'Matches fake pattern: {pattern}'}
        
        # Check for suspicious names
        suspicious_indicators = [
            ('placeholder', 'Contains "placeholder"'),
            ('example', 'Contains "example"'),
            ('demo', 'Contains "demo"'),
            ('test', 'Contains "test"'),
            ('fake', 'Contains "fake"'),
            ('dummy', 'Contains "dummy"'),
            ('mock', 'Contains "mock"'),
            ('sample', 'Contains "sample"'),
        ]
        
        for indicator, reason in suspicious_indicators:
            if indicator in lower_name:
                return {'is_fake': True, 'reason': reason}
        
        # Check for overly generic names
        generic_names = {'library', 'module', 'package', 'tool', 'utility', 'helper'}
        if lower_name in generic_names:
            return {'is_fake': True, 'reason': 'Overly generic name'}
        
        return {'is_fake': False, 'reason': ''}

    def extract_packages_from_code(self, code: str) -> List[str]:
        """Extract package names from code text"""
        packages = set()
        
        # Python import patterns
        python_patterns = [
            r'^\s*(?:import|from)\s+([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)',
            r'pip\s+install\s+([a-zA-Z_][a-zA-Z0-9_\-]*)',
            r'pip3\s+install\s+([a-zA-Z_][a-zA-Z0-9_\-]*)',
            r'poetry\s+add\s+([a-zA-Z_][a-zA-Z0-9_\-]*)',
            r'conda\s+install\s+([a-zA-Z_][a-zA-Z0-9_\-]*)'
        ]
        
        for pattern in python_patterns:
            matches = re.findall(pattern, code, re.MULTILINE)
            for match in matches:
                # Take only the first part (module.submodule -> module)
                package = match.split('.')[0]
                packages.add(package)
        
        # npm/Node.js patterns
        npm_patterns = [
            r'npm\s+install\s+([@a-zA-Z_][a-zA-Z0-9_\-]*)',
            r'yarn\s+add\s+([@a-zA-Z_][a-zA-Z0-9_\-]*)',
            r'require\([\'"]([@a-zA-Z_][a-zA-Z0-9_\-]*)[\'"]\)',
            r'import\s+.*from\s+[\'"]([@a-zA-Z_][a-zA-Z0-9_\-]*)[\'"]'
        ]
        
        for pattern in npm_patterns:
            matches = re.findall(pattern, code, re.MULTILINE)
            packages.update(matches)
        
        return sorted(list(packages))

    def validate_code_snippet(self, code: str, repository: str = 'pypi') -> List[Dict]:
        """Validate all packages in a code snippet"""
        packages = self.extract_packages_from_code(code)
        results = []
        
        print(f"📦 Found {len(packages)} package(s) in code:")
        for pkg in packages:
            print(f"  - {pkg}")
        
        print(f"\n🔍 Validating packages on {repository.upper()}...")
        print("=" * 60)
        
        for package in packages:
            result = self.search_package(package, repository)
            results.append(result)
            
            # Display result
            if result['is_fake_likely']:
                print(f"❓ {package}: LIKELY FAKE - {result['fake_reason']}")
            elif result['exists']:
                details = result['details']
                version = details.get('version', 'N/A')
                print(f"✅ {package}: REAL (v{version})")
                if details.get('summary'):
                    print(f"   📝 {details['summary'][:80]}...")
            else:
                print(f"❌ {package}: NOT FOUND")
                if result['details'].get('error'):
                    print(f"   ⚠️  {result['details']['error']}")
            print()
        
        return results

    def generate_report(self, results: List[Dict]) -> Dict:
        """Generate summary report"""
        total = len(results)
        real = sum(1 for r in results if r['exists'])
        fake = sum(1 for r in results if r['is_fake_likely'])
        not_found = total - real - fake
        
        report = {
            'total_packages': total,
            'real_packages': real,
            'likely_fake': fake,
            'not_found': not_found,
            'real_packages_list': [r['package'] for r in results if r['exists']],
            'fake_packages_list': [r['package'] for r in results if r['is_fake_likely']],
            'not_found_list': [r['package'] for r in results if not r['exists'] and not r['is_fake_likely']]
        }
        
        return report

def main():
    parser = argparse.ArgumentParser(description='Check if packages in code are real or made-up')
    parser.add_argument('--code', type=str, help='Code snippet to analyze')
    parser.add_argument('--file', type=str, help='File containing code to analyze')
    parser.add_argument('--repo', choices=['pypi', 'npm'], default='pypi', 
                       help='Package repository to check (default: pypi)')
    parser.add_argument('--list', type=str, help='Comma-separated list of packages to check')
    
    args = parser.parse_args()
    
    validator = PackageValidator()
    
    if args.list:
        packages = [pkg.strip() for pkg in args.list.split(',')]
        results = []
        for package in packages:
            result = validator.search_package(package, args.repo)
            results.append(result)
            
            if result['is_fake_likely']:
                print(f"❓ {package}: LIKELY FAKE - {result['fake_reason']}")
            elif result['exists']:
                print(f"✅ {package}: REAL")
            else:
                print(f"❌ {package}: NOT FOUND")
    
    elif args.file:
        try:
            with open(args.file, 'r', encoding='utf-8') as f:
                code = f.read()
        except FileNotFoundError:
            print(f"Error: File '{args.file}' not found")
            sys.exit(1)
        
        results = validator.validate_code_snippet(code, args.repo)
        
    elif args.code:
        results = validator.validate_code_snippet(args.code, args.repo)
    
    else:
        # Example usage
        example_code = """
import numpy as np
import pandas as pd
import fake_package
from example_module import something
import my_custom_lib

# Installation commands
pip install requests
pip install made-up-library
npm install non-existent-package
"""
        
        print("=" * 60)
        print("EXAMPLE: Validating packages in sample code")
        print("=" * 60)
        results = validator.validate_code_snippet(example_code, 'pypi')
    
    # Generate and display report
    report = validator.generate_report(results)
    
    print("=" * 60)
    print("📊 VALIDATION REPORT")
    print("=" * 60)
    print(f"Total packages checked: {report['total_packages']}")
    print(f"✅ Real packages: {report['real_packages']}")
    print(f"❓ Likely fake: {report['likely_fake']}")
    print(f"❌ Not found: {report['not_found']}")
    
    if report['fake_packages_list']:
        print(f"\n⚠️  Likely fake packages:")
        for pkg in report['fake_packages_list']:
            print(f"   - {pkg}")
    
    if report['not_found_list']:
        print(f"\n🔍 Packages not found (might be real but private/custom):")
        for pkg in report['not_found_list']:
            print(f"   - {pkg}")

if __name__ == "__main__":
    main()