skylos 1.0.10__py3-none-any.whl → 2.5.2__py3-none-any.whl

test/diagnostics.py

@@ -1,364 +0,0 @@
-#!/usr/bin/env python3
-import sys
-import json
-import subprocess
-import re
-from pathlib import Path
-
-def load_ground_truth(path):
-    """Load the ground truth data from a ground_truth.json file with the Skylos test structure"""
-    try:
-        with open(path, 'r') as f:
-            data = json.load(f)
-            
-            dead_items = []
-            if "files" in data and "code.py" in data["files"]:
-                if "dead_items" in data["files"]["code.py"]:
-                    return data["files"]["code.py"]["dead_items"]
-            
-            return []
-    except Exception as e:
-        print(f"Error loading ground truth from {path}: {e}")
-        return []
-
-def run_skylos_on_file(code_file, skylos_path):
-    try:
-        cmd = [sys.executable, skylos_path, str(code_file)]
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        
-        if result.returncode != 0:
-            print(f"Error running Skylos subprocess: {result.stderr}")
-            return {}
-        
-        json_start = result.stdout.find('{')
-        if json_start > -1:
-            json_str = result.stdout[json_start:]
-            try:
-                return json.loads(json_str)
-            except json.JSONDecodeError:
-                print(f"Error parsing Skylos JSON output")
-                return {}
-        else:
-            print(f"Could not find JSON in output")
-            return {}
-    except Exception as e:
-        print(f"Error running Skylos: {e}")
-        return {}
-
-def run_vulture_on_file(code_file, confidence=0):
-    try:
-        cmd = ["vulture", str(code_file), f"--min-confidence={confidence}"]
-        result = subprocess.run(cmd, capture_output=True, text=True)
-        
-        items = []
-        pattern = r"([^:]+):(\d+): (\w+) '([^']+)' is never used"
-        
-        for line in result.stdout.splitlines():
-            match = re.search(pattern, line)
-            if match:
-                filename, lineno, item_type, name = match.groups()
-                
-                if item_type == "unused variable":
-                    continue
-                elif item_type == "unused import":
-                    normalized_type = "import"
-                elif item_type == "unused class":
-                    normalized_type = "class"
-                elif item_type == "unused function":
-                    if "." in name:
-                        normalized_type = "method"
-                    else:
-                        normalized_type = "function"
-                elif item_type == "unused method":
-                    normalized_type = "method"
-                elif item_type == "unused property":
-                    normalized_type = "method" 
-                else:
-                    normalized_type = item_type.replace("unused ", "")
-                
-                if normalized_type == "method" and "." in name:
-                    items.append({
-                        "name": name,
-                        "type": normalized_type,
-                        "file": filename,
-                        "line": int(lineno)
-                    })
-                else:
-                    items.append({
-                        "name": name,
-                        "type": normalized_type,
-                        "file": filename,
-                        "line": int(lineno)
-                    })
-        
-        return items
-    except Exception as e:
-        print(f"Error running Vulture on {code_file}: {e}")
-        return []
-
-def normalize_item(item):
-    if isinstance(item, str):
-        return item
-    
-    name = item.get("name", "")
-    
-    if item.get("type") == "method" and "." in name:
-        parts = name.split(".")
-        if len(parts) > 2:
-            return ".".join(parts[-2:])
-        return name
-    
-    # for other types, just get the last part
-    if "." in name:
-        return name.split(".")[-1]
-    
-    return name
-
-def get_skylos_results_as_list(skylos_results):
-    """Convert Skylos JSON results to a flat list of items"""
-    result = []
-    
-    for item in skylos_results.get("unused_functions", []):
-        # try to determine if its a method or function based on name
-        if "." in item["name"]:
-            item_type = "method"
-        else:
-            item_type = "function"
-        
-        result.append({
-            "name": item["name"],
-            "type": item_type,
-            "file": item.get("file", ""),
-            "line": item.get("line", 0)
-        })
-    
-    for item in skylos_results.get("unused_imports", []):
-        result.append({
-            "name": item["name"],
-            "type": "import",
-            "file": item.get("file", ""),
-            "line": item.get("line", 0)
-        })
-    
-    for item in skylos_results.get("unused_classes", []):
-        result.append({
-            "name": item["name"],
-            "type": "class",
-            "file": item.get("file", ""),
-            "line": item.get("line", 0)
-        })
-    
-    return result
-
-def find_test_cases(test_dir):
-    """Find all test cases in the directory structure"""
-    test_cases = []
-    
-    for path in Path(test_dir).rglob("ground_truth.json"):
-        code_file = path.parent / "code.py"
-        if code_file.exists():
-            test_cases.append({
-                "name": path.parent.name,
-                "code_file": code_file,
-                "ground_truth_file": path
-            })
-    
-    return test_cases
-
-def compare_results(skylos_results, vulture_results, ground_truth, test_case):
-    """Compare tool results with ground truth for a single test case"""
-    gt_normalized = set()
-    for item in ground_truth:
-        if isinstance(item, dict):
-            gt_normalized.add((normalize_item(item), item.get("type")))
-    
-    skylos_flat = get_skylos_results_as_list(skylos_results)
-    skylos_normalized = set()
-    for item in skylos_flat:
-        skylos_normalized.add((normalize_item(item), item.get("type")))
-    
-    vulture_normalized = set()
-    for item in vulture_results:
-        vulture_normalized.add((normalize_item(item), item.get("type")))
-    
-    skylos_tp = skylos_normalized.intersection(gt_normalized)
-    skylos_fp = skylos_normalized - gt_normalized
-    skylos_fn = gt_normalized - skylos_normalized
-    
-    vulture_tp = vulture_normalized.intersection(gt_normalized)
-    vulture_fp = vulture_normalized - gt_normalized
-    vulture_fn = gt_normalized - vulture_normalized
-    
-    vulture_only_tp = vulture_tp - skylos_tp
-    
-    skylos_only_tp = skylos_tp - vulture_tp
-    
-    return {
-        "name": test_case["name"],
-        "ground_truth_count": len(gt_normalized),
-        "skylos": {
-            "tp": skylos_tp,
-            "fp": skylos_fp,
-            "fn": skylos_fn,
-            "tp_count": len(skylos_tp),
-            "fp_count": len(skylos_fp),
-            "fn_count": len(skylos_fn),
-            "precision": len(skylos_tp) / len(skylos_normalized) if skylos_normalized else 0,
-            "recall": len(skylos_tp) / len(gt_normalized) if gt_normalized else 0,
-        },
-        "vulture": {
-            "tp": vulture_tp,
-            "fp": vulture_fp,
-            "fn": vulture_fn, 
-            "tp_count": len(vulture_tp),
-            "fp_count": len(vulture_fp),
-            "fn_count": len(vulture_fn),
-            "precision": len(vulture_tp) / len(vulture_normalized) if vulture_normalized else 0,
-            "recall": len(vulture_tp) / len(gt_normalized) if gt_normalized else 0,
-        },
-        "vulture_only_tp": vulture_only_tp,
-        "skylos_only_tp": skylos_only_tp
-    }
-
-def print_test_result(result):
-    """Print results for a single test case"""
-    print(f"\n=== Test Case: {result['name']} ===")
-    print(f"Ground Truth: {result['ground_truth_count']} items")
-    
-    print("\nSkylos Results:")
-    print(f"  True Positives: {result['skylos']['tp_count']}")
-    print(f"  False Positives: {result['skylos']['fp_count']}")
-    print(f"  False Negatives: {result['skylos']['fn_count']}")
-    print(f"  Precision: {result['skylos']['precision']:.4f}")
-    print(f"  Recall: {result['skylos']['recall']:.4f}")
-    
-    print("\nVulture Results:")
-    print(f"  True Positives: {result['vulture']['tp_count']}")
-    print(f"  False Positives: {result['vulture']['fp_count']}")
-    print(f"  False Negatives: {result['vulture']['fn_count']}")
-    print(f"  Precision: {result['vulture']['precision']:.4f}")
-    print(f"  Recall: {result['vulture']['recall']:.4f}")
-    
-    if result['skylos']['fp_count'] > 0:
-        print("\nSkylos False Positives (items Skylos flags that should be used):")
-        for item in result['skylos']['fp']:
-            print(f"  - {item[0]} ({item[1]})")
-    
-    if result['skylos']['fn_count'] > 0:
-        print("\nSkylos False Negatives (items Skylos misses that should be flagged):")
-        for item in result['skylos']['fn']:
-            print(f"  - {item[0]} ({item[1]})")
-    
-    if result['vulture_only_tp']:
-        print("\nVulture-only True Positives (What Vulture catches correctly but Skylos misses):")
-        for item in result['vulture_only_tp']:
-            print(f"  - {item[0]} ({item[1]})")
-    
-    if result['skylos_only_tp']:
-        print("\nSkylos-only True Positives (What Skylos catches correctly but Vulture misses):")
-        for item in result['skylos_only_tp']:
-            print(f"  - {item[0]} ({item[1]})")
-
-def main():
-    if len(sys.argv) < 3:
-        print("Usage: python analyze_test_cases.py <skylos_path> <test_cases_dir>")
-        return
-    
-    skylos_path = sys.argv[1]
-    test_dir = sys.argv[2]
-    
-    print(f"Finding test cases in {test_dir}...")
-    test_cases = find_test_cases(test_dir)
-    print(f"Found {len(test_cases)} test cases.")
-    
-    total_results = {
-        "test_cases": len(test_cases),
-        "ground_truth_total": 0,
-        "skylos": {
-            "tp_total": 0,
-            "fp_total": 0,
-            "fn_total": 0,
-            "precision_avg": 0,
-            "recall_avg": 0
-        },
-        "vulture": {
-            "tp_total": 0,
-            "fp_total": 0,
-            "fn_total": 0,
-            "precision_avg": 0,
-            "recall_avg": 0
-        },
-        "problem_cases": []
-    }
-    
-    test_results = []
-    for test_case in test_cases:
-        print(f"\nProcessing test case: {test_case['name']}...")
-        
-        ground_truth = load_ground_truth(test_case["ground_truth_file"])
-        total_results["ground_truth_total"] += len(ground_truth)
-        
-        skylos_results = run_skylos_on_file(test_case["code_file"], skylos_path)
-        
-        vulture_results = run_vulture_on_file(test_case["code_file"])
-        
-        result = compare_results(skylos_results, vulture_results, ground_truth, test_case)
-        test_results.append(result)
-        
-        total_results["skylos"]["tp_total"] += result["skylos"]["tp_count"]
-        total_results["skylos"]["fp_total"] += result["skylos"]["fp_count"]
-        total_results["skylos"]["fn_total"] += result["skylos"]["fn_count"]
-        total_results["skylos"]["precision_avg"] += result["skylos"]["precision"]
-        total_results["skylos"]["recall_avg"] += result["skylos"]["recall"]
-        
-        total_results["vulture"]["tp_total"] += result["vulture"]["tp_count"]
-        total_results["vulture"]["fp_total"] += result["vulture"]["fp_count"] 
-        total_results["vulture"]["fn_total"] += result["vulture"]["fn_count"]
-        total_results["vulture"]["precision_avg"] += result["vulture"]["precision"]
-        total_results["vulture"]["recall_avg"] += result["vulture"]["recall"]
-        
-        if result["skylos"]["fp_count"] > 0 or result["skylos"]["fn_count"] > 0:
-            total_results["problem_cases"].append({
-                "name": test_case["name"],
-                "fp": result["skylos"]["fp_count"],
-                "fn": result["skylos"]["fn_count"]
-            })
-        
-        print_test_result(result)
-    
-    if test_cases:
-        total_results["skylos"]["precision_avg"] /= len(test_cases)
-        total_results["skylos"]["recall_avg"] /= len(test_cases)
-        total_results["vulture"]["precision_avg"] /= len(test_cases)
-        total_results["vulture"]["recall_avg"] /= len(test_cases)
-    
-    print("\n=== OVERALL SUMMARY ===")
-    print(f"Total Test Cases: {total_results['test_cases']}")
-    print(f"Total Ground Truth Items: {total_results['ground_truth_total']}")
-    
-    print("\nSkylos Overall Results:")
-    print(f"  Total True Positives: {total_results['skylos']['tp_total']}")
-    print(f"  Total False Positives: {total_results['skylos']['fp_total']}")
-    print(f"  Total False Negatives: {total_results['skylos']['fn_total']}")
-    print(f"  Average Precision: {total_results['skylos']['precision_avg']:.4f}")
-    print(f"  Average Recall: {total_results['skylos']['recall_avg']:.4f}")
-    
-    print("\nVulture Overall Results:")
-    print(f"  Total True Positives: {total_results['vulture']['tp_total']}")
-    print(f"  Total False Positives: {total_results['vulture']['fp_total']}")
-    print(f"  Total False Negatives: {total_results['vulture']['fn_total']}")
-    print(f"  Average Precision: {total_results['vulture']['precision_avg']:.4f}")
-    print(f"  Average Recall: {total_results['vulture']['recall_avg']:.4f}")
-    
-    if total_results["problem_cases"]:
-        print("\nProblem Test Cases (with Skylos FP or FN):")
-        sorted_problems = sorted(total_results["problem_cases"], 
-                                key=lambda x: x["fp"] + x["fn"], 
-                                reverse=True)
-        for case in sorted_problems:
-            print(f"  - {case['name']} (FP: {case['fp']}, FN: {case['fn']})")
-        
-        print("\nRecommendation: Fix these specific test cases to improve Skylos performance.")
-
-if __name__ == "__main__":
-    main()

test/sample_repo/app.py

@@ -1,13 +0,0 @@
-import os
-import sys
-import json  # Unused import
-import logging
-from .sample_repo.routes import create_app
-
-def main():
-    """Run the application"""
-    app = create_app()
-    app.run()
-
-if __name__ == "__main__":
-    main()

test/sample_repo/sample_repo/commands.py

@@ -1,81 +0,0 @@
-import os
-import sys
-import argparse
-import csv  # Unused import
-from functools import wraps
-
-from sample_repo import User, Product
-from sample_repo import get_current_time
-
-def register_commands():
-    """Register CLI commands - used function."""
-    parser = argparse.ArgumentParser(description='Sample CLI')
-    subparsers = parser.add_subparsers(dest='command')
-    
-    user_parser = subparsers.add_parser('user', help='User commands')
-    user_parser.add_argument('action', choices=['list', 'create'])
-    
-    product_parser = subparsers.add_parser('product', help='Product commands')
-    product_parser.add_argument('action', choices=['list'])
-    
-    return parser
-
-def handle_user_command(args):
-    """Handle user command - used function."""
-    if args.action == 'list':
-        users = [
-            User('john', 'john@example.com'),
-            User('alice', 'alice@example.com')
-        ]
-        for user in users:
-            print(f"User: {user.username} ({user.email})")
-    elif args.action == 'create':
-        user = User('new_user', 'new@example.com')
-        print(f"Created user: {user.username} ({user.email})")
-
-def handle_product_command(args):
-    """Handle product command - used function."""
-    if args.action == 'list':
-        products = [
-            Product('Laptop', 999.99),
-            Product('Phone', 499.99)
-        ]
-        for product in products:
-            print(f"Product: {product.name} - ${product.price:.2f}")
-
-def export_data(data, filename):
-    """Export data to CSV - unused function."""
-    with open(filename, 'w', newline='') as f:
-        writer = csv.writer(f)
-        writer.writerow(['id', 'name', 'value'])
-        for item in data:
-            writer.writerow([item['id'], item['name'], item['value']])
-
-def import_data(filename):
-    """Import data from CSV - unused function."""
-    data = []
-    with open(filename, 'r', newline='') as f:
-        reader = csv.reader(f)
-        next(reader)
-        for row in reader:
-            data.append({
-                'id': row[0],
-                'name': row[1],
-                'value': row[2]
-            })
-    return data
-
-class CommandDecorator:
-    """Decorator for CLI commands - unused class."""
-    
-    def __init__(self, name, help_text):
-        self.name = name
-        self.help_text = help_text
-    
-    def __call__(self, func):
-        """Call method - unused method."""
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            print(f"Executing command: {self.name}")
-            return func(*args, **kwargs)
-        return wrapper

test/sample_repo/sample_repo/models.py

@@ -1,122 +0,0 @@
-import datetime
-import uuid
-import hashlib  # Unused import
-from typing import List, Dict, Optional
-
-from .utils import get_current_time
-
-class BaseModel:
-    """Base model class with common functionality."""
-    
-    def __init__(self, id=None):
-        self.id = id or str(uuid.uuid4())
-        self.created_at = get_current_time()
-    
-    def to_dict(self):
-        """Convert model to dictionary - used method."""
-        return {
-            'id': self.id,
-            'created_at': self.created_at
-        }
-    
-    def to_json(self):
-        """Convert model to JSON - unused method."""
-        import json
-        return json.dumps(self.to_dict())
-    
-    @classmethod
-    def from_dict(cls, data):
-        """Create instance from dictionary - used method."""
-        instance = cls(id=data.get('id'))
-        if 'created_at' in data:
-            instance.created_at = data['created_at']
-        return instance
-
-class User(BaseModel):
-    """User model - used class."""
-    
-    def __init__(self, username, email, id=None):
-        super().__init__(id)
-        self.username = username
-        self.email = email
-        self.active = True
-    
-    def to_dict(self):
-        """Override to_dict to include user fields - used method."""
-        data = super().to_dict()
-        data.update({
-            'username': self.username,
-            'email': self.email,
-            'active': self.active
-        })
-        return data
-    
-    def deactivate(self):
-        """Deactivate user - used method."""
-        self.active = False
-    
-    def send_welcome_email(self):
-        """Send welcome email - unused method."""
-        pass
-
-class Product(BaseModel):
-    """Product model - used class."""
-    
-    def __init__(self, name, price, id=None):
-        super().__init__(id)
-        self.name = name
-        self.price = price
-    
-    def to_dict(self):
-        """Override to_dict for product - used method."""
-        data = super().to_dict()
-        data.update({
-            'name': self.name,
-            'price': self.price
-        })
-        return data
-    
-    def apply_discount(self, percentage):
-        """Apply discount to product - unused method."""
-        self.price = self.price * (1 - percentage / 100)
-
-class Order(BaseModel):
-    """Order model - unused class."""
-    
-    def __init__(self, user_id, products, id=None):
-        super().__init__(id)
-        self.user_id = user_id
-        self.products = products
-        self.status = 'pending'
-    
-    def to_dict(self):
-        """Order to dict - unused method."""
-        data = super().to_dict()
-        data.update({
-            'user_id': self.user_id,
-            'products': self.products,
-            'status': self.status
-        })
-        return data
-    
-    def complete(self):
-        """Mark order as complete - unused method."""
-        self.status = 'completed'
-
-class Cart:
-    """Shopping cart - unused class."""
-    
-    def __init__(self, user_id):
-        self.user_id = user_id
-        self.items = []
-    
-    def add_item(self, product_id, quantity=1):
-        """Add item to cart - unused method."""
-        self.items.append({
-            'product_id': product_id,
-            'quantity': quantity
-        })
-    
-    def clear(self):
-        """Clear cart - unused method."""
-        self.items = []

test/sample_repo/sample_repo/routes.py

@@ -1,89 +0,0 @@
-import os
-import json
-import logging
-from functools import wraps
-
-from sample_repo import User, Product
-from sample_repo import format_currency
-
-def require_auth(f):
-    """Decorator to require authentication - used decorator."""
-    @wraps(f)
-    def decorated(*args, **kwargs):
-        return f(*args, **kwargs)
-    return decorated
-
-def rate_limit(limit):
-    """Decorator for rate limiting - unused decorator."""
-    def decorator(f):
-        @wraps(f)
-        def decorated(*args, **kwargs):
-            return f(*args, **kwargs)
-        return decorated
-    return decorator
-
-class App:
-    """Simple application class - used class."""
-    
-    def __init__(self):
-        self.routes = {}
-        self.middlewares = []
-        self._setup_routes()
-    
-    def _setup_routes(self):
-        """Set up API routes - used method."""
-        self.routes = {
-            '/users': self.get_users,
-            '/users/create': self.create_user,
-            '/products': self.get_products
-        }
-    
-    def add_middleware(self, middleware):
-        """Add middleware - unused method."""
-        self.middlewares.append(middleware)
-    
-    @require_auth
-    def get_users(self):
-        """Get users endpoint - used method."""
-        users = [
-            User('john', 'john@example.com'),
-            User('alice', 'alice@example.com')
-        ]
-        return [user.to_dict() for user in users]
-    
-    def create_user(self):
-        """Create user endpoint - used method."""
-        user = User('new_user', 'new@example.com')
-        return user.to_dict()
-    
-    def get_products(self):
-        """Get products endpoint - used method."""
-        products = [
-            Product('Laptop', 999.99),
-            Product('Phone', 499.99)
-        ]
-        return [
-            {**product.to_dict(), 'formatted_price': format_currency(product.price)}
-            for product in products
-        ]
-    
-    @rate_limit(100)
-    def get_analytics(self):
-        """Get analytics endpoint - unused method."""
-        return {'visits': 1000, 'unique_users': 500}
-    
-    def run(self):
-        """Run the application - used method."""
-        print("API server running...")
-
-def create_app():
-    """Create application - used function."""
-    return App()
-
-def parse_config(config_path):
-    """Parse configuration file - unused function."""
-    if not os.path.exists(config_path):
-        return {}
-    
-    with open(config_path, 'r') as f:
-        return json.load(f)