🎵 Media Library Deep Dive

from abc import ABC, abstractmethod
from typing import List, Optional

class Media(ABC):
    def __init__(self, title: str, artist: str, duration: int):
        self.title = title
        self.artist = artist
        self._duration = duration

    @property
    def duration(self) -> int:
        return self._duration

    @property
    def duration_str(self) -> str:
        minutes, seconds = divmod(self._duration, 60)
        hours, minutes = divmod(minutes, 60)
        if hours:
            return f"{hours}h {minutes}m {seconds}s"
        elif minutes:
            return f"{minutes}m {seconds}s"
        return f"{seconds}s"

    def is_long(self, threshold: int = 600) -> bool:
        return self._duration > threshold

    @abstractmethod
    def play(self) -> str:
        pass

    @abstractmethod
    def info(self) -> str:
        pass

    def __str__(self) -> str:
        return self.info()

class AudioMedia(Media):
    def __init__(self, title: str, artist: str, duration: int,
                 audio_format: str = "mp3", bitrate: int = 128):
        super().__init__(title, artist, duration)
        self.audio_format = audio_format
        self.bitrate = bitrate

    def format_info(self) -> str:
        return f"{self.audio_format.upper()} @ {self.bitrate} kbps"

class VideoMedia(Media):
    def __init__(self, title: str, artist: str, duration: int,
                 resolution: str = "1080p", framerate: int = 30):
        super().__init__(title, artist, duration)
        self.resolution = resolution
        self.framerate = framerate

    def video_info(self) -> str:
        return f"{self.resolution} @ {self.framerate}fps"

class Song(AudioMedia):
    def __init__(self, title: str, artist: str, duration: int,
                 album: str = "Unknown", **kwargs):
        super().__init__(title, artist, duration, **kwargs)
        self.album = album

    def play(self) -> str:
        return f"🎵 ♪ Now playing: {self.title} by {self.artist} ({self.duration_str})"

    def info(self) -> str:
        return f"🎵 Song: {self.title} | Artist: {self.artist} | Album: {self.album} | {self.duration_str} | {self.format_info()}"

class Podcast(AudioMedia):
    def __init__(self, title: str, artist: str, duration: int,
                 episode: int = 1, **kwargs):
        super().__init__(title, artist, duration, **kwargs)
        self.episode = episode

    def play(self) -> str:
        return f"🎙️ Now playing: {self.title} — Episode {self.episode} ({self.duration_str})"

    def info(self) -> str:
        return f"🎙️ Podcast: {self.title} | Host: {self.artist} | Episode {self.episode} | {self.duration_str} | {self.format_info()}"

class Movie(VideoMedia):
    def __init__(self, title: str, artist: str, duration: int,
                 director: str, **kwargs):
        super().__init__(title, artist, duration, **kwargs)
        self.director = director

    def play(self) -> str:
        return f"🎬 Now playing: {self.title} ({self.duration_str}) — Directed by {self.director}"

    def info(self) -> str:
        return f"🎬 Movie: {self.title} | Director: {self.director} | {self.duration_str} | {self.video_info()}"

class Library:
    def __init__(self, name: str):
        self.name = name
        self._items: List[Media] = []

    def add(self, item: Media) -> None:
        self._items.append(item)

    def play_all(self) -> None:
        for item in self._items:
            print(item.play())

    def search_by_artist(self, artist: str) -> List[Media]:
        return [item for item in self._items if item.artist.lower() == artist.lower()]

    def get_long_media(self, threshold: int = 600) -> List[Media]:
        return [item for item in self._items if item.is_long(threshold)]

    def __len__(self) -> int:
        return len(self._items)

    def display_report(self) -> None:
        print(f"\n📚 {self.name} Library Report")
        print(f"Total items: {len(self)}")
        for item in self._items:
            print(f"  - {item.info()}")

# --- Demonstration ---
def demonstrate_polymorphism(items: List[Media]) -> None:
    print("\n🎯 Polymorphism in action:")
    for item in items:
        print(item.play())
        print(item.info())
        print("-" * 40)

# Build the library
library = Library("Poetic Bytes")

# Add various media
library.add(Song("Bohemian Rhapsody", "Queen", 354, "A Night at the Opera", bitrate=320))
library.add(Song("Shape of You", "Ed Sheeran", 233))
library.add(Podcast("Tech Talk", "Sarah Johnson", 2400, episode=42, audio_format="aac"))
library.add(Movie("Inception", "Christopher Nolan", 8880, "Christopher Nolan", resolution="4K"))
library.add(Movie("The Matrix", "Wachowski Sisters", 8160, "Lana & Lilly Wachowski"))

# Display the library report
library.display_report()

# Show polymorphism
demonstrate_polymorphism(library._items[:3])

# Demonstrate search and filtering
print("\n🔍 Search results for 'Queen':")
for item in library.search_by_artist("Queen"):
    print(f"  - {item.info()}")

print("\n⏱️ Long media (> 10 minutes):")
for item in library.get_long_media(600):
    print(f"  - {item.info()}")

# Demonstrate MRO
print("\n📐 Method Resolution Order for Song:")
print([cls.__name__ for cls in Song.__mro__])