Abstraction

from abc import ABC, abstractmethod

# 🎨 Abstract class - a TEMPLATE that says "what" but not "how"
class Shape(ABC):
    
    @abstractmethod
    def area(self):
        """Calculate and return the area"""
        pass  # No implementation! Just a promise.
    
    @abstractmethod
    def perimeter(self):
        """Calculate and return the perimeter"""
        pass
    
    # Non-abstract method - has implementation
    def describe(self):
        print(f"I am a shape with area: {self.area()}")

# ❌ This will ERROR - can't create abstract class directly
# shape = Shape()  # TypeError!

# ✅ Concrete classes MUST implement all abstract methods
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):  # ✅ Implemented!
        return 3.14159 * self.radius ** 2
    
    def perimeter(self):  # ✅ Implemented!
        return 2 * 3.14159 * self.radius

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):  # ✅ Implemented!
        return self.width * self.height
    
    def perimeter(self):  # ✅ Implemented!
        return 2 * (self.width + self.height)

# Now we can use them!
circle = Circle(5)
rect = Rectangle(4, 6)

print(f"Circle area: {circle.area()}")          # 78.54
print(f"Rectangle perimeter: {rect.perimeter()}")  # 20
circle.describe()  # Uses the non-abstract method

from abc import ABC, abstractmethod

class PaymentGateway(ABC):
    """Abstract payment gateway - defines WHAT operations are available"""
    
    @abstractmethod
    def connect(self):
        """Connect to the payment service"""
        pass
    
    @abstractmethod
    def authenticate(self, credentials):
        """Authenticate with the service"""
        pass
    
    @abstractmethod
    def process_payment(self, amount, card_details):
        """Process the actual payment"""
        pass
    
    @abstractmethod
    def disconnect(self):
        """Clean up connection"""
        pass
    
    # Template method - uses abstract methods
    def make_payment(self, amount, card_details, credentials):
        """High-level payment flow - same for all gateways"""
        print(f"\n💳 Processing ${amount:.2f} payment...")
        
        self.connect()
        if self.authenticate(credentials):
            result = self.process_payment(amount, card_details)
            self.disconnect()
            return result
        
        self.disconnect()
        return False

# Concrete implementation for Stripe
class StripeGateway(PaymentGateway):
    def connect(self):
        print("   🔌 Connecting to Stripe API...")
    
    def authenticate(self, credentials):
        print(f"   🔐 Authenticating with API key: {credentials[:8]}...")
        return True  # Simplified
    
    def process_payment(self, amount, card_details):
        print(f"   💰 Stripe processing ${amount:.2f}...")
        print(f"   ✅ Payment successful! Stripe ID: ch_123abc")
        return True
    
    def disconnect(self):
        print("   👋 Disconnected from Stripe")

# Concrete implementation for PayPal
class PayPalGateway(PaymentGateway):
    def connect(self):
        print("   🔌 Connecting to PayPal sandbox...")
    
    def authenticate(self, credentials):
        print(f"   🔐 OAuth2 authentication...")
        return True
    
    def process_payment(self, amount, card_details):
        print(f"   💰 PayPal processing ${amount:.2f}...")
        print(f"   ✅ Payment successful! PayPal ID: PAY-xyz789")
        return True
    
    def disconnect(self):
        print("   👋 PayPal session closed")

# Concrete implementation for Square
class SquareGateway(PaymentGateway):
    def connect(self):
        print("   🔌 Initializing Square terminal...")
    
    def authenticate(self, credentials):
        print(f"   🔐 Square access token verified")
        return True
    
    def process_payment(self, amount, card_details):
        print(f"   💰 Square processing ${amount:.2f}...")
        print(f"   ✅ Payment successful! Square ID: sq_456def")
        return True
    
    def disconnect(self):
        print("   👋 Square terminal disconnected")

# 🎯 The user doesn't care about implementation details!
# They just call make_payment() on any gateway

print("=" * 50)
print("Testing different payment gateways")
print("=" * 50)

stripe = StripeGateway()
stripe.make_payment(99.99, {"card": "****1234"}, "sk_test_12345")

paypal = PayPalGateway()
paypal.make_payment(49.99, {"card": "****5678"}, "client_id_xyz")

square = SquareGateway()
square.make_payment(29.99, {"card": "****9999"}, "sq_access_token")

from abc import ABC, abstractmethod

class GameEngine(ABC):
    """Abstract game engine - hide rendering complexity"""
    
    @abstractmethod
    def initialize(self):
        pass
    
    @abstractmethod
    def render_sprite(self, sprite, x, y):
        pass
    
    @abstractmethod
    def play_sound(self, sound_file):
        pass
    
    @abstractmethod
    def check_collision(self, obj1, obj2):
        pass
    
    # Template for game loop
    def run_frame(self, game_objects):
        for obj in game_objects:
            self.render_sprite(obj.sprite, obj.x, obj.y)

class Unity2DEngine(GameEngine):
    def initialize(self):
        print("🎮 Unity 2D initializing...")
        print("   Loading shaders, setting up OpenGL context...")
    
    def render_sprite(self, sprite, x, y):
        print(f"   [Unity] Drawing '{sprite}' at ({x}, {y})")
    
    def play_sound(self, sound_file):
        print(f"   [Unity] Playing '{sound_file}' via FMOD")
    
    def check_collision(self, obj1, obj2):
        print(f"   [Unity] Box2D collision check...")
        return False

class PygameEngine(GameEngine):
    def initialize(self):
        print("🎮 Pygame initializing...")
        print("   pygame.init() called, display created...")
    
    def render_sprite(self, sprite, x, y):
        print(f"   [Pygame] blit '{sprite}' at ({x}, {y})")
    
    def play_sound(self, sound_file):
        print(f"   [Pygame] mixer.Sound('{sound_file}').play()")
    
    def check_collision(self, obj1, obj2):
        print(f"   [Pygame] rect.colliderect() check...")
        return False

# Game developer doesn't need to know engine internals!
class GameObject:
    def __init__(self, name, sprite, x, y):
        self.name = name
        self.sprite = sprite
        self.x = x
        self.y = y

# Same game code works with different engines
def run_game(engine):
    print("\n" + "=" * 50)
    engine.initialize()
    
    objects = [
        GameObject("Player", "hero.png", 100, 200),
        GameObject("Enemy", "monster.png", 300, 200),
    ]
    
    engine.run_frame(objects)
    engine.play_sound("jump.wav")

print("Testing with Unity:")
run_game(Unity2DEngine())

print("\nTesting with Pygame:")
run_game(PygameEngine())

from abc import ABC, abstractmethod

# ABSTRACTION - hiding complexity of HOW something works
class DatabaseConnection(ABC):
    @abstractmethod
    def connect(self): pass
    
    @abstractmethod
    def query(self, sql): pass

# ENCAPSULATION - hiding and protecting DATA
class User:
    def __init__(self, name, password):
        self.name = name
        self.__password = password  # 🔒 Hidden data
    
    def check_password(self, attempt):
        return attempt == self.__password  # Controlled access

┌─────────────────────────────────────────────┐
│              Your Application               │  ← You write this
│         (Just calls simple methods)         │
├─────────────────────────────────────────────┤
│              Framework Layer                │  ← Abstracts complexity
│      (Django, Flask, FastAPI, etc.)         │
├─────────────────────────────────────────────┤
│              Library Layer                  │  ← More abstractions
│    (requests, SQLAlchemy, Pillow, etc.)     │
├─────────────────────────────────────────────┤
│            Language Runtime                 │  ← Python abstracts C
│               (Python)                      │
├─────────────────────────────────────────────┤
│           Operating System                  │  ← OS abstracts hardware
│        (Windows, Linux, macOS)              │
├─────────────────────────────────────────────┤
│               Hardware                      │  ← The complex reality
│     (CPU, Memory, Disk, Network)            │
└─────────────────────────────────────────────┘

# What YOU write (simple):
with open("data.txt", "w") as f:
    f.write("Hello!")

# What Python ACTUALLY does (complex):
# 1. Ask OS to create file descriptor
# 2. Allocate memory buffer
# 3. Convert string to bytes
# 4. Handle different file systems
# 5. Manage disk sectors
# 6. Handle concurrent access
# 7. Flush buffers to disk
# 8. Release file descriptor
# 9. Free memory

# All that complexity is ABSTRACTED away! ✨

from abc import ABC, abstractmethod

# This is essentially an INTERFACE
class Printable(ABC):
    @abstractmethod
    def to_string(self):
        pass
    
    @abstractmethod
    def print_formatted(self):
        pass

class Invoice(Printable):
    def __init__(self, number, amount):
        self.number = number
        self.amount = amount
    
    def to_string(self):
        return f"Invoice #{self.number}: ${self.amount}"
    
    def print_formatted(self):
        print("╔════════════════════════════╗")
        print(f"║  Invoice: {self.number:>15} ║")
        print(f"║  Amount:  ${self.amount:>13.2f} ║")
        print("╚════════════════════════════╝")

class Report(Printable):
    def __init__(self, title, data):
        self.title = title
        self.data = data
    
    def to_string(self):
        return f"Report: {self.title}"
    
    def print_formatted(self):
        print(f"\n📊 {self.title}")
        print("-" * 30)
        for key, value in self.data.items():
            print(f"  {key}: {value}")

# Any Printable can be printed!
def print_document(doc: Printable):
    print(doc.to_string())
    doc.print_formatted()

invoice = Invoice("INV-001", 1250.00)
report = Report("Sales Summary", {"Q1": "$10k", "Q2": "$15k", "Q3": "$12k"})

print_document(invoice)
print_document(report)