Rule of Three in Python

class RuleOfThree:
    def __init__(self):
        self.history = []

    def calculate_direct(self, a: float, b: float, c: float) -> float:
        """
        Calculate direct proportion using Rule of Three.
        
        Args:
            a: First value
            b: Second value (corresponds to a)
            c: Third value
        
        Returns:
            float: Calculated proportional value
        """
        if a == 0:
            raise ValueError("First value cannot be zero")
        
        result = (b * c) / a
        self.history.append({
            'type': 'direct',
            'values': (a, b, c),
            'result': result
        })
        return result

    def calculate_inverse(self, a: float, b: float, c: float) -> float:
        """
        Calculate inverse proportion using Rule of Three.
        
        Args:
            a: First value
            b: Second value (corresponds to a)
            c: Third value
        
        Returns:
            float: Calculated proportional value
        """
        if c == 0:
            raise ValueError("Third value cannot be zero")
        
        result = (a * b) / c
        self.history.append({
            'type': 'inverse',
            'values': (a, b, c),
            'result': result
        })
        return result

    def get_history(self) -> list:
        """Get calculation history."""
        return self.history

# Decorator for input validation
def validate_inputs(func):
    def wrapper(self, a: float, b: float, c: float) -> float:
        if not all(isinstance(x, (int, float)) for x in (a, b, c)):
            raise TypeError("All inputs must be numbers")
        if any(x < 0 for x in (a, b, c)):
            raise ValueError("Negative values are not allowed")
        return func(self, a, b, c)
    return wrapper

class EnhancedRuleOfThree(RuleOfThree):
    @validate_inputs
    def calculate_direct(self, a: float, b: float, c: float) -> float:
        return super().calculate_direct(a, b, c)

    @validate_inputs
    def calculate_inverse(self, a: float, b: float, c: float) -> float:
        return super().calculate_inverse(a, b, c)

    def get_formatted_history(self) -> str:
        """Get calculation history in formatted string."""
        return "\n".join(
            f"Type: {calc['type']}, Values: {calc['values']}, Result: {calc['result']}"
            for calc in self.history
        )