Polymorphism in Python — Missing .serialize() Export

# Three completely unrelated classes — no shared base class
class HtmlWidget:
    def __init__(self, content):
        self.content = content

    def render(self):
        # Returns an HTML string representation
        return f"<div>{self.content}</div>"


class PdfSection:
    def __init__(self, text):
        self.text = text

    def render(self):
        # Returns a simulated PDF text block
        return f"[PDF BLOCK] {self.text}"


class ConsoleMessage:
    def __init__(self, message):
        self.message = message

    def render(self):
        # Returns a plain terminal string
        return f">>> {self.message}"


def display_all(renderable_items):
    """
    This function doesn't know or care what TYPE each item is.
    It only requires that each item has a .render() method.
    That's duck typing — the contract is the method, not the class.
    """
    for item in renderable_items:
        print(item.render())  # Calls whichever .render() belongs to this object


# Mix completely different types in the same list — Python handles it gracefully
page_components = [
    HtmlWidget("Welcome to TheCodeForge"),
    PdfSection("Chapter 1: Polymorphism"),
    ConsoleMessage("Build complete — 0 errors"),
]

display_all(page_components)

from abc import ABC, abstractmethod
import datetime


class Notification(ABC):
    """
    Abstract base class — defines the CONTRACT every notification must honour.
    You cannot instantiate this directly; it's a blueprint only.
    """

    def __init__(self, recipient, message):
        self.recipient = recipient
        self.message = message
        self.timestamp = datetime.datetime.now().strftime("%H:%M:%S")

    @abstractmethod
    def send(self):
        """
        Every subclass MUST implement this method.
        The @abstractmethod decorator enforces the contract at class creation time.
        """
        pass

    def log(self):
        # Shared behaviour — all notifications log themselves the same way
        # Subclasses inherit this without overriding it
        print(f"[{self.timestamp}] Notification queued for {self.recipient}")


class EmailNotification(Notification):
    def __init__(self, recipient, message, subject):
        super().__init__(recipient, message)  # Reuse parent's __init__ logic
        self.subject = subject

    def send(self):
        # Overrides the abstract send() with email-specific behaviour
        self.log()  # Calls the shared parent method
        print(f"  EMAIL to {self.recipient}")
        print(f"  Subject: {self.subject}")
        print(f"  Body: {self.message}")


class SmsNotification(Notification):
    def send(self):
        # Completely different implementation — same method name, different behaviour
        self.log()
        print(f"  SMS to {self.recipient}: {self.message[:160]}")  # SMS character limit


class SlackNotification(Notification):
    def __init__(self, recipient, message, channel):
        super().__init__(recipient, message)
        self.channel = channel

    def send(self):
        self.log()
        print(f"  SLACK -> #{self.channel} @{self.recipient}: {self.message}")


def dispatch_notifications(notifications):
    """
    This function is completely decoupled from the specific notification types.
    Add a new channel (PushNotification, WhatsApp...) and this function
    needs ZERO changes — that's polymorphism delivering real value.
    """
    for notification in notifications:
        notification.send()  # Python resolves the correct .send() at runtime
        print()  # Blank line for readability


# Build a mixed list of notification types
notification_queue = [
    EmailNotification("alice@example.com", "Your order has shipped!", "Order Update"),
    SmsNotification("+447911123456", "Your OTP is 847291. Valid for 5 minutes."),
    SlackNotification("deployment-bot", "Production deploy successful v2.4.1", "engineering"),
]

dispatch_notifications(notification_queue)

class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price

    def __repr__(self):
        # Called when Python needs a developer-friendly string representation
        # e.g. inside a list, or in the REPL
        return f"Product('{self.name}', £{self.price:.2f})"


class ShoppingCart:
    def __init__(self, owner):
        self.owner = owner
        self.items = []  # Stores Product objects

    def add(self, product):
        self.items.append(product)
        return self  # Enables method chaining: cart.add(a).add(b)

    def __len__(self):
        # len(cart) now works naturally — returns number of items
        return len(self.items)

    def __contains__(self, product_name):
        # 'in' operator: 'Headphones' in cart
        return any(item.name == product_name for item in self.items)

    def __add__(self, other_cart):
        """
        Merge two carts with the + operator.
        Returns a brand-new cart — doesn't mutate either original.
        Follows the principle of least surprise: x + y shouldn't change x.
        """
        merged = ShoppingCart(f"{self.owner} & {other_cart.owner}")
        merged.items = self.items + other_cart.items  # Combine item lists
        return merged

    def __gt__(self, other_cart):
        # cart_a > cart_b compares total value — feels natural
        return self.total() > other_cart.total()

    def __str__(self):
        # str(cart) or print(cart) gives a human-readable summary
        item_lines = "\n".join(f"  - {item.name}: £{item.price:.2f}" for item in self.items)
        return f"Cart ({self.owner}):\n{item_lines}\n  TOTAL: £{self.total():.2f}"

    def total(self):
        return sum(item.price for item in self.items)


# --- Putting it all together ---

alice_cart = ShoppingCart("Alice")
alice_cart.add(Product("Keyboard", 79.99)).add(Product("Mouse", 29.99))

bob_cart = ShoppingCart("Bob")
bob_cart.add(Product("Headphones", 149.99)).add(Product("USB Hub", 24.99))

# __len__ in action
print(f"Alice has {len(alice_cart)} items in her cart")

# __contains__ in action
print(f"'Mouse' in Alice's cart: {'Mouse' in alice_cart}")
print(f"'Headphones' in Alice's cart: {'Headphones' in alice_cart}")

# __gt__ comparison
print(f"Bob's cart is more expensive: {bob_cart > alice_cart}")

# __add__ to merge carts
combined_cart = alice_cart + bob_cart
print(f"\nMerged cart has {len(combined_cart)} items")

# __str__ for a clean printout
print(f"\n{combined_cart}")

from abc import ABC, abstractmethod
from collections.abc import Iterable, Sized


class Drawable(ABC):
    """
    Explicit interface: any subclass MUST implement draw().
    No more guessing what methods to provide.
    """
    @abstractmethod
    def draw(self):
        pass


class Circle(Drawable):
    def __init__(self, radius):
        self.radius = radius

    def draw(self):
        print(f"Drawing a circle with radius {self.radius}")


class Square(Drawable):
    def __init__(self, side):
        self.side = side

    def draw(self):
        print(f"Drawing a square with side {self.side}")


# This line would raise TypeError: Can't instantiate abstract class Drawable
# d = Drawable()


class Canvas:
    def __init__(self):
        self.shapes = []

    def add(self, shape):
        # We're still using duck typing here — any object with .draw() works.
        # But the ABC gives us confidence that the contract is solid.
        self.shapes.append(shape)

    def render_all(self):
        for shape in self.shapes:
            shape.draw()


# Using collections.abc to make our own sizeable container
class Team(Iterable, Sized):
    def __init__(self, members):
        self._members = members

    def __iter__(self):
        return iter(self._members)

    def __len__(self):
        return len(self._members)


# Now Team works with len(), for x in, sorted() etc.
my_team = Team(["Alice", "Bob", "Charlie"])
print(f"Team size: {len(my_team)}")
for member in my_team:
    print(f"  - {member}")

# The sorted() function works on anything that's Iterable.
# Here's custom iterable that generates Fibonacci numbers.

class FibonacciIterable:
    """
    Implements the Iterable protocol (__iter__) to work with sorted().
    """
    def __init__(self, count):
        self.count = count

    def __iter__(self):
        a, b = 0, 1
        for _ in range(self.count):
            yield a
            a, b = b, a + b


fib = FibonacciIterable(10)
# Can't call sorted() on this directly? Actually sorted() calls iter() internally.
# But FibonacciIterable is not a sequence, so the elements come out in order.
# To demonstrate polymorphism, we can reverse it or use min/max.

# Works with min() and max() — they call __iter__
print(f"Min: {min(fib)}")  # 0

# Also works with list() which accepts any iterable
numbers = list(fib)  # But fib is exhausted after min()! So create a new one.
numbers2 = list(FibonacciIterable(10))
print(f"Numbers: {numbers2}")  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

# Demonstrating file-like duck typing with json module
import json
from io import StringIO

class CustomWriter:
    """A custom class that behaves like a file — has .write() method."""
    def __init__(self):
        self.buffer = []

    def write(self, text):
        self.buffer.append(text)

    def getvalue(self):
        return ''.join(self.buffer)


writer = CustomWriter()
data = {"name": "Polymorphism", "type": "duck"}
json.dump(data, writer)  # json.dump only requires .write()
print(writer.getvalue())  # {"name": "Polymorphism", "type": "duck"}