PyBug Hunter - Advanced Python Bug Detection System

# Advanced test case with multiple bug patterns
import math
from typing import List, Optional

# Variable scope and shadowing issues
x = 10
def shadow_example():
    x = 20  # Variable shadowing
    print(x)

# Uninitialized variable
def process_data(items):
    total = total + 1  # Uninitialized variable usage
    for item in items:
        result += item  # Another uninitialized variable
    return result

# Index and dict access issues
def access_examples():
    data = [1, 2, 3]
    value = data[5]  # IndexError risk
    
    config = {'name': 'test'}
    debug = config['debug']  # KeyError risk
    
    # Safe access pattern missing
    if config['verbose']:  # KeyError risk
        print("Verbose mode")

# Loop issues
def loop_issues():
    # Modifying list during iteration
    numbers = [1, 2, 3, 4, 5]
    for num in numbers:
        if num % 2 == 0:
            numbers.remove(num)  # Dangerous modification
    
    # Infinite loop risk
    i = 0
    while i < 10:
        print(i)
        # Missing increment
    
    # Inefficient loop
    data = [1, 2, 3, 4, 5]
    for i in range(len(data)):
        for j in range(len(data)):  # O(n²) for simple task
            if data[i] == data[j]:
                pass

# Function argument issues
def process_user(name: str, age: int, email: str = None):
    return f"{name} is {age} years old"

def call_examples():
    # Missing argument
    process_user("Alice")  # Missing age argument
    
    # Extra argument
    process_user("Bob", 25, "bob@test.com", "extra")  # Too many arguments
    
    # Wrong argument order
    process_user(30, "Charlie")  # Type mismatch risk

# None handling issues
def process_value(value: Optional[int]):
    result = value * 2  # None multiplication risk
    return result

def none_checks():
    data = None
    length = len(data)  # NoneType error
    
    if data is None:  # Good check
        pass

# Logical errors
def logical_errors(score):
    # Always true condition
    if score > 0 or score <= 0:
        return "Always true"
    
    # Assignment instead of comparison
    if score = 10:
        print("Score is 10")
    
    # Redundant condition
    if score > 5 and score > 3:  # Redundant
        pass
    
    # Deep nesting
    if score > 0:
        if score > 10:
            if score > 20:
                if score > 30:
                    if score > 40:
                        return "Deep nesting"

# Closure and lambda issues
def create_multipliers():
    return [lambda x: i * x for i in range(5)]  # Late binding issue

def closure_example():
    funcs = []
    for i in range(3):
        def inner():
            return i  # Late binding - returns last i
        funcs.append(inner)
    return funcs

# Floating point precision
def float_issues():
    a = 0.1 + 0.2  # Precision issue (0.30000000000000004)
    if a == 0.3:  # Never true
        print("Equal")
    
    # Accumulating errors
    total = 0.0
    for _ in range(1000):
        total += 0.1  # Accumulating floating point error
    
    # Better approach
    from decimal import Decimal
    b = Decimal('0.1') + Decimal('0.2')

# Type tracking
def type_confusion():
    value = "10"
    result = value + 5  # Type error
    return result

# Main execution
if __name__ == "__main__":
    shadow_example()
    process_data([])
    access_examples()
    loop_issues()
    call_examples()
    process_value(None)
    logical_errors(15)
    create_multipliers()
    float_issues()
    type_confusion()
0 Total Issues
0 🔴 High
0 🟡 Medium
0 🔵 Low
0 🟣 Info
0 ms
Deep Analysis Results

Running deep multi-pass analysis...