Implementação de duck typing e classes abstratas

from abc import ABC, abstractmethod, abstractproperty


class Watchable:
    _id_tracker = 0

    def __init__(self, name, year):
        self._name = name.title()
        self.year = year
        self._likes = 0
        self._id = self.new_id()

    def __str__(self):
        return f"{self.name} ({self.year}) - {self.likes} likes"

    def __repr__(self):
        return f"{self.__class__.__name__}(name={self.name}, year={self.year}, likes={self.likes}, id={self.id})"

    @property
    def name(self):
        return self._name

    @name.setter
    def name(self, new_name):
        if not new_name:
            raise ValueError("Gotta have a name!")
        self._name = new_name.title()

    @property
    def likes(self):
        return self._likes

    @likes.setter
    def likes(self, new_amount):
        if not isinstance(new_amount, int):
            raise TypeError("Amount of likes needs to be an integer.")
        if new_amount < 0:
            raise ValueError("There are no negative likes.")
        self._likes = new_amount

    @property
    def id(self):
        return self._id

    @property
    def type(self):
        return self.__class__.__name__

    @classmethod
    def new_id(cls):
        cls._id_tracker += 1
        return cls._id_tracker

    def add_like(self, occurrences):
        if occurrences < 0:
            raise ValueError("Can't decrement likes.")
        self.likes += occurrences

    def _add_trashcan_icon(self):
        return f" - \U0001F5D1" if self.likes == 0 else ""

    @abstractmethod
    def play(self):
        print("Implement this method in a subclass.")
        raise NotImplementedError("Subclass must implement abstract method")

    @property
    @abstractmethod
    def description(self):
        print("Implement this method in a subclass.")
        raise NotImplementedError("Subclass must implement abstract method")


class Movie(Watchable):

    def __init__(self, name, year, length):
        super().__init__(name, year)
        self.length = length

    def __str__(self):
        trash = self._add_trashcan_icon()
        return f"{self.name} ({self.year}) - {self.length} min - {self.likes} likes{trash}"

    def play(self):
        print(f"Playing movie: {self.name} ({self.year})")

    @property
    def description(self):
        return f"This movie is called {self.name} and it's {self.length} minutes long."


class Series(Watchable):

    def __init__(self, name, year, seasons):
        super().__init__(name, year)
        self.seasons = seasons

    def __str__(self):
        formatted_seasons = SmallNumberFormatter.format_small_numbers(
            self.seasons)
        trash = self._add_trashcan_icon()
        return f"{self.name} ({self.year}) - {formatted_seasons} seasons - {self.likes} likes{trash}"

    def play(self):
        print(f"Playing series: {self.name} ({self.year})")

    @property
    def description(self):
        return f"This series is called {self.name} and it ran for {SmallNumberFormatter.format_small_numbers(self.seasons)} seasons."


class Playlist:

    def __init__(self, name, items):
        self.name = name
        self.items = items

    def __str__(self):
        formatted_size = SmallNumberFormatter.format_small_numbers(
            len(self.items) if len(self.items) >= 10 else len(self.items))
        playlist_str = f"Here's your {self.name} playlist with {formatted_size} items total:\n"
        for index, item in enumerate(self.items):
            playlist_str += f"{index + 1}) {item} ({item.id})\n"
        return playlist_str

    def __getitem__(self, item):
        return self.items[item]

    def __contains__(self, item):
        return item in self.items

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

    def average_likes(self):
        return sum(item.likes for item in self.items) / len(self.items) if len(
            self.items) > 0 else 0

    def total_movie_runtime(self):
        return sum(item.length for item in self.items
                   if isinstance(item, Movie))


class SmallNumberFormatter:
    WORDS = {
        number: word
        for number, word in enumerate(
            'zero one two three four five six seven eight nine ten'.split(), 0)
    }

    @staticmethod
    def format_small_numbers(number):
        return SmallNumberFormatter.WORDS.get(number, str(number))