Practical session

class Blackboard:
  """ Represents a blackboard with a surface that can be written on, read and erase.
  """
  def __init__(self) -> None:
    """
    Initializes a new instance of the Blackboard class.
    """
    self._surface: str = ""

  def write(self, text: str) -> None:
    """
    Writes the specified text on the surface of the blackboard.

    Parameters:
    -----------
    text: str
        The text to be written on the surface of the blackboard.
    """
    if text != "":
        # Add a new line if the text is not empty
        self._surface += '\n'

    self._surface += text

  def read(self) -> str:
    """
    Returns the text written on the surface of the blackboard.
    """
    return self._surface

  def show(self) -> None:
    """
    Shows the text written on the surface of the blackboard.
    """
    print(self._surface)

  def erase(self) -> None:
    """
    Erases the text written on the surface of the blackboard.
    """
    if self._surface != "":
        self._surface = ""

if __name__ == "__main__":
  one_blackboard = Blackboard()
  one_blackboard.write("Hello world")
  one_blackboard.show()
  one_blackboard.erase()
  if one_blackboard.read() != "":
    print("Error: The blackboard should be empty")

class BankAccount:
    """
    Represents a bank account with a balance and a transaction history.
    """
    def __init__(self, account_number: int) -> None:
        """
        Initializes a new instance of the BankAccount class.

        Parameters:
        -----------
        account_number: int
            The account number.
        """
        self._account_number: int = account_number
        self._balance: float = 0.0
        self._history: list[float] = []

    def deposit(self, amount: float) -> None:
        """
        Deposits money into the bank account.

        Parameters:
        -----------
        amount: int
            The amount to be deposited into the account.
        Raises:
        -------
        ValueError: If the amount is not positive.
        """
        if amount <= 0:
            raise ValueError("Amount must be positive")
        else:
            self._balance += amount
            self._history.append(amount)

    def withdraw(self, amount: float) -> None:
        """
        Withdraws money from the bank account.

        Parameters:
        -----------
        amount: float
            The amount to be withdrawn from the account.
        Raises:
        -------
        ValueError: If the amount is not positive or greater than the balance.
        """
        if amount <= 0:
            raise ValueError("Amount must be positive")
        elif amount > self._balance:
            raise ValueError("Amount must be less than the balance")
        else:
            self._balance -= amount
            self._history.append(-amount)

    def get_account_number(self) -> int:
        """
        Returns the account number of the bank account.
        """
        return self._account_number

    def get_balance(self) -> float:
        """
        Returns the balance of the bank account.

        Returns:
        --------
        The balance of the bank account.
        """
        return self._balance

    def get_transaction_history(self) -> list[float]:
        """
        Returns the transaction history of the bank account.

        Returns:
        --------
        The transaction history of the bank account.
        """
        return self._history

if __name__ == "__main__":
    my_account = BankAccount(1)
    my_account.deposit(500)
    my_account.deposit(200)
    try:
        my_account.deposit(-50)
    except ValueError as e:
        print("ERROR", e)
    try:
        my_account.withdraw(10000)
    except ValueError as e:
        print("ERROR", e)
    try:
        my_account.withdraw(-50)
    except ValueError as e:
        print("ERROR", e)

    my_account.withdraw(100)
    print("Transaction history:", my_account.get_transaction_history()) # Should give [500, 200, -100]
    print("Balance:", my_account.get_balance()) # Should give 600

from person import Person


class BankAccount:
    """
    Represents a bank account with a number, an owner, a balance, and a transaction history.
    """

    def __init__(self, account_number: int, owner: Person) -> None:
        """
        Initializes a new instance of the BankAccount class. Adds the account to the owner's list of accounts.

        Parameters:
        -----------
        account_number: int
            The account number.
        owner: Person
            The owner of the account.
        Raises:
        -------
        ValueError: If the owner is None.
        """
        if owner is None:
            raise ValueError("Owner must be specified")
        self._account_number: int = account_number
        self._owner: Person = owner
        self._balance: float = 0
        self._history: list[float] = []
        # The owner adds the new account to his/her list of accounts
        owner.add_account(self)

    def deposit(self, amount: float) -> None:
        """
        Deposits the specified amount to the balance of the bank account.

        Parameters:
        -----------
        amount: float
            The amount to deposit.
        Raises:
        -------
        ValueError: If the amount is not positive.
        """
        if amount < 0:
            raise ValueError("Amount must be positive")
        self._balance += amount
        self._history.append(amount)

    def withdraw(self, amount: float) -> None:
        """
        Withdraws the specified amount from the balance of the bank account.

        Parameters:
        -----------
        amount: float
            The amount to withdraw.
        Raises:
        -------
        ValueError: If the amount is not positive or greater than the balance.
        """
        if 0 < amount <= self._balance:
            self._balance -= amount
            self._history.append(-amount)
        else:
            raise ValueError("Amount must be positive and less than the balance")

    def get_account_number(self) -> int:
        """
        Returns the account number of the bank account.
        """
        return self._account_number

    def get_balance(self) -> float:
        """
        Returns the balance of the bank account.

        Returns:
        --------
        The balance of the bank account.
        """
        return self._balance

    def get_transaction_history(self) -> list[float]:
        """
        Returns the transaction history of the bank account.

        Returns:
        --------
        The transaction history of the bank account.
        """
        return self._history

    def get_owner(self) -> Person:
        """
        Returns the owner of the bank account.

        Returns:
        --------
        The owner of the bank account.
        """
        return self._owner

    def __str__(self) -> str:
        return f"Account number {self._account_number} from {self._owner.fullname()} has {self._balance} € and has done {len(self._history)} transactions"

    def __repr__(self) -> str:
        return f"Account number {self._account_number}: {self._owner.fullname()} has {self._balance} € and has done {len(self._history)} transactions"

from __future__ import annotations

from typing import *

if TYPE_CHECKING:
    from bankaccount import BankAccount


class Person:
    """Represents a person with a name, firstname, age and the list of bank accounts."""

    def __init__(self, name: str, firstname: str, age: int) -> None:  # The constructor
        """Constructs a new Person object with the specified lastname, firstname, age, and his/her accounts."""
        self._lastname: str = name.upper()
        self._firstname: str = firstname
        self._age: int = age
        self._accounts: list[BankAccount] = []

    def fullname(self) -> str:
        return f"{self._firstname} {self._lastname}"

    def get_accounts(self) -> list[BankAccount]:
        """Returns the list of bank accounts of the person."""
        return self._accounts

    def add_account(self, account: BankAccount) -> None:
        """Adds the specified bank account to the list of bank accounts of the person if it is not already present.
        Args:
            account (BankAccount): The bank account to add.
        """

        if account not in self._accounts:
            self._accounts.append(account)

    def remove_account(self, account: BankAccount) -> None:
        """Removes the specified bank account from the list of bank accounts of the person.
        Args:
            account (BankAccount): The bank account to remove.
        """
        if account in self._accounts:
            self._accounts.remove(account)

    def __str__(self) -> str:
        """Returns a string representation of the Person object."""
        return f"{self._firstname} {self._lastname} ({self._age} old) has {len(self._accounts)} bank accounts"

    def __eq__(self, other: object) -> bool:
        """Compares two Person objects.
        Args:
            other (object): The object to compare with.
        Returns:
            bool: `True` if the objects are equal, `False` otherwise.
            Two persons are equal if they have the same lastname, firstname and age.
        """
        # Both objects should be instances of the same class (Person)
        if not isinstance(other, Person):
            return False
        return (
            self._firstname == other._firstname
            and self._lastname == other._lastname
            and self._age == other._age
        )

from bankaccount import BankAccount
from person import Person

if __name__ == "__main__":

    # Create a person
    alice_weber = Person("Weber", "Alice", 33)
    print(alice_weber)  # Should give no bank account

    # Create three bank accounts for Alice
    alice_account1 = BankAccount(1, alice_weber)
    alice_account2 = BankAccount(2, alice_weber)
    alice_account3 = BankAccount(3, alice_weber)

    print(alice_weber)  # Should give three bank accounts

    # Make some transactions
    alice_account1.deposit(500)
    alice_account2.deposit(1000)
    print(alice_account1)  # Should give 500
    print(alice_account2)  # Should give 1000

    alice_account2.withdraw(30)
    print(alice_account2)  # Should give 970

    # Remove the second bank account from Alice's accounts
    alice_weber.remove_account(alice_account2)
    print(alice_weber)  # Should give two bank accounts

    # If there is no money in account 3 add some
    if alice_account3.get_balance() == 0:
        alice_account3.deposit(5000)
    print(alice_account3)  # Should give 5000 and 1 transaction

    # Show the balance of all accounts of alice
    str_elements = ""
    for element in alice_weber.get_accounts():
        str_elements += str(element) + "; "
    print(str_elements)

    # Optional. Test __eq__ method
    new_alice = Person("Weber", "Alice", 33)
    if alice_account1.get_owner() == new_alice:
        print("get_owner Success. new_alice and alice_weber are the same person")
    else:
        print("get_owner Failure. new_alice and alice_weber are not the same person")

from person import Person
from bankaccount import BankAccount


class ElectedOfficial(Person):
    """
    Represents an elected official with a list of assistants.
    It inherits from the Person class.
    """

    def __init__(self, name: str, firstname: str, age: int) -> None:  # The constructor
        """
        Constructs a new ElectedOfficial object with the specified lastname, firstname, age
        He/she has no assistants.

        Parameters:
        -----------
        name: str
            The lastname of the elected official.
        firstname: str
            The firstname of the elected official.
        age: int
            The age of the elected official.
        """
        super().__init__(
            name, firstname, age
        )  # Call the constructor of the parent class
        self._assistants: list[Person] = []

    def hire_assistant(self, assistant: Person) -> None:
        """
        Adds the specified assistant to the list of assistants of the elected official if it is not already in it.

        Parameters:
        -----------
        assistant: Person
            The assistant to add.
        """
        if assistant is not None:
            self._assistants.append(assistant)

    def fire_assistant(self, assistant: Person) -> None:
        """
        Removes the specified assistant from the list of assistants of the elected official if it exists.

        Parameters:
        -----------
        assistant: Person
            The assistant to remove.
        """
        if assistant in self._assistants:
            self._assistants.remove(assistant)

    def get_assistants(self) -> list[Person]:
        """
        Returns the list of assistants of the elected official.

        Returns:
        --------
        The list of assistants of the elected official.
        """
        return self._assistants

    def spend_allocation(self, amount: float) -> dict[str, float]:
        """
        Distributes the specified amount equally between the assistants of the elected official if the amount is positive.
        If an assistant has no bank account, he/she receives no money

        Parameters:
        -----------
        amount: float
            The amount to distribute.

        Returns: for each assistant with no bank account the amount to be given

        Raises:
        -------
        ValueError: if amount is < 0
        """
        if amount < 0:
            raise ValueError("The amount to distribute should be positive")

        result = {}
        for assistant in self._assistants:  # For each assistant
            assistant_accounts = assistant.get_accounts()
            if len(assistant_accounts) == 0:  # The assistant has no accounts yet
                result[assistant.fullname()] = amount / len(self._assistants)
            else:
                # Finding the account with the minimal balance. Option 1
                min_balance_account = min(
                    assistant_accounts, key=lambda account: account.get_balance()
                )
                # Finding the account with the minimal balance. Option 2
                # min_balance_account = assistant_accounts[0]
                # for account in assistant_accounts:
                #     if account.get_balance() < min_balance_account.get_balance():
                #         min_balance_account = account

                # Deposit the corresponding money
                min_balance_account.deposit(amount / len(self._assistants))
        return result

    def __str__(self) -> str:
        """
        Returns a string representation of the ElectedOfficial object.
        Uses the parent method to get a string representation of the ElectedOfficial object.
        """
        return super().__str__() + f" and {len(self._assistants)} assistants"

if __name__ == "__main__":

    # Create an elected representative
    michael_ducas = ElectedOfficial("Michael", "Ducas", 33)
    print(
        f"Elected Representative {michael_ducas}\n"
    )  # Should give no bank account and no assistants

    # Create assistants of michael_ducas. No bank account
    david_landon = Person("David", "Landon", 25)

    # Create a second assistant. One bank account
    linda_lucas = Person("Lucas", "Linda", 30)
    linda_lucas.add_account(BankAccount(1, linda_lucas))

    # Create the third assistant. Two bank accounts
    yann_breizh = Person("Breizh", "Yann", 28)
    yann_breizh.add_account(BankAccount(2, yann_breizh))
    yann_account = BankAccount(3, yann_breizh)
    yann_breizh.add_account(yann_account)
    yann_account.deposit(200)

    # Hire an assistant
    michael_ducas.hire_assistant(david_landon)
    print(
        f"Elected Representative {michael_ducas}\n"
    )  # Should give no bank account and 1 assistant

    # Try to distribute 1000 euros: no distribution
    try:
        print(michael_ducas.spend_allocation(1000))
    except ValueError as e:
        print(e)
    # Show information on balance on assistants accounts
    for assistant in michael_ducas.get_assistants():
        assistant_accounts = assistant.get_accounts()
        for account in assistant_accounts:
            print(
                f"Assistant {assistant.fullname()}: account nber {account.get_account_number()} with balance {account.get_balance()}\n"
            )

    # Hire Linda Lucas
    michael_ducas.hire_assistant(linda_lucas)
    # Try to distribute 2000 euros: account transfer to Linda
    # Manual to David Landon
    try:
        print(michael_ducas.spend_allocation(2000))
    except ValueError as e:
        print(e)
    # Show information on balance on assistants accounts
    for assistant in michael_ducas.get_assistants():
        assistant_accounts = assistant.get_accounts()
        for account in assistant_accounts:
            print(
                f"Assistant {assistant.fullname()}: account nber {account.get_account_number()} with balance {account.get_balance()}\n"
            )

    # Hire Yann Breizh
    michael_ducas.hire_assistant(yann_breizh)
    # Try to distribute 1500 euros: account transfer to Linda and Yann (account 3)
    # Manual to David Landon
    try:
        print(michael_ducas.spend_allocation(2000))
    except ValueError as e:
        print(e)
    # Show information on balance on assistants accounts
    for assistant in michael_ducas.get_assistants():
        assistant_accounts = assistant.get_accounts()
        for account in assistant_accounts:
            print(
                f"Assistant {assistant.fullname()}: account nber {account.get_account_number()} with balance {account.get_balance()}\n"
            )

from __future__ import annotations


class RussianDoll:
    """
    Represents a Russian doll with a size, a state (opened or closed), a content and a container.
    """

    def __init__(self, size: int) -> None:
        """
        Initializes a new instance of the RussianDoll class.

        Parameters:
        -----------
        size: int
            The size of the doll.
        """
        self.size: int = size
        self._opened: bool = False
        self._content: RussianDoll | None = None
        self.placed_in: RussianDoll | None = None

    def open(self) -> None:
        """
        Opens the doll if it is not already open and if it is not inside another doll.
        """
        if not self._opened and self.placed_in is None:
            self._opened = True

    def close(self) -> None:
        """
        Closes the doll if it is not already closed and if it is not inside another doll.
        """
        if self._opened and self.placed_in is None:
            self._opened = False

    def place_in(self, p: RussianDoll) -> None:
        """
        Places the current doll in doll p, if possible.
        The current doll must be closed and not already inside another doll.
        p must be opened and contain no doll, and it must be larger than the current doll.

        Parameters:
        -----------
        p: RussianDoll
            The doll in which to place the current doll.
        """
        if (
            not self._opened
            and self.placed_in is None
            and p._opened
            and p._content is None
            and p.size > self.size
        ):
            self.placed_in = p
            p._content = self

    def get_out(self, p: RussianDoll) -> None:
        """
        Takes the current doll out of doll p if it's in p and if p is open.

        Parameters:
        -----------
        p: RussianDoll
            The doll from which to take out the current doll.
        """
        if self.placed_in == p and p._opened:
            self.placed_in = None
            p._content = None

    def __str__(self) -> str:
        """
        Returns a string representation of the doll, including its size and state.
        """
        state = "open" if self._opened else "closed"
        content = f"contains doll {self._content.size}" if self._content else "is empty"
        return f"Doll {self.size} is {state} and {content}"


def visualize_dolls(dolls: list[RussianDoll]) -> None:
    """
    Prints a visualization of all the Russian dolls and their relationships.

    Parameters:
    -----------
    dolls: list[RussianDoll]
        The list of Russian dolls to visualize.
    """
    for doll in dolls:
        container = (
            f"inside doll {doll.placed_in.size}"
            if doll.placed_in
            else "not inside any doll"
        )
        print(f"Doll: {doll} and is {container}.")


if __name__ == "__main__":
    # Create three russian dolls of different sizes
    russian_doll1 = RussianDoll(1)
    russian_doll2 = RussianDoll(2)
    russian_doll3 = RussianDoll(3)

    # Lets put dolls inside one another
    russian_doll3.open()
    russian_doll2.open()
    russian_doll1.place_in(russian_doll2)
    russian_doll2.close()
    russian_doll2.place_in(russian_doll3)

    # Visualize the relationships
    visualize_dolls([russian_doll1, russian_doll2, russian_doll3])

    russian_doll2.get_out(russian_doll3)
    # Visualize the relationships
    visualize_dolls([russian_doll1, russian_doll2, russian_doll3])

class Ingredient:
    """
    Represents an ingredient with a name, quantity, state, unit and price.
    """
    def __init__(self, name: str, quantity: int, state: str, unit: str, price: float):
        """
        Initializes a new instance of the Ingredient class.

        Parameters:
        -----------
        name: str
            The name of the ingredient.
        quantity: int
            The quantity of the ingredient.
        state: str
            The state of the ingredient (raw or cooked).
        unit: str
            The unit of the ingredient (g, kg, ml, cl, l).
        price: float
            The price of the ingredient.
        Raises:
        -------
        ValueError: If the quantity is negative, the unit is not valid, the state is not valid or the price is negative.
        """
        if quantity < 0:
            raise ValueError("Quantity must be positive")
        if unit.lower() not in ("g", "kg", "ml", "cl", "l"):
            raise ValueError("Unit must be 'g','kg', 'ml', 'cl', or 'l'")
        if state.lower() not in ("raw", "cooked"):
            raise ValueError("State must be 'raw' or 'cooked'")
        if price < 0:
            raise ValueError("Price must be positive")

        self._name = name
        self._quantity = quantity
        self._unit = unit.lower()
        self._state = state.lower()
        self._price = price

    def __str__(self) -> str:
        """
        Returns a string representation of the Ingredient object.
        """
        return f"{self._quantity}{self._unit} {self._name} ({self._state}, {self._price}€)"

    def __eq__(self, other: 'Ingredient') -> bool:
        """
        Compares two Ingredient objects.
        Two ingredients are equal if they have the same name and state.

        Parameters:
        -----------
        other: Ingredient
            The ingredient to compare with.

        Returns:
        --------
        bool: True if the ingredients are equal, False otherwise.
        """
        return self._name == other._name and self._state == other._state

class Meal:
    """
    Represents a meal with a name and a list of ingredients.
    """

    def __init__(self, name: str, ingredients: list[Ingredient] = []) -> None:
        """
        Initializes a new instance of the Meal class.

        Parameters:
        -----------
        name: str
            The name of the meal.
        ingredients: List[Ingredient]
            The list of ingredients of the meal, may be empty.
        """
        self._name: str = name
        self._ingredients: list[Ingredient] = ingredients

    def add_ingredient(self, ingredient: Ingredient):
        """
        Adds an ingredient to the meal.

        Parameters:
        -----------
        ingredient: Ingredient
            The ingredient to add.
        """
        self._ingredients.append(ingredient)

    def remove_ingredient(self, ingredient: Ingredient):
        """
        Removes an ingredient from the meal.

        Parameters:
        -----------
        ingredient: Ingredient
            The ingredient to remove.
        """
        self._ingredients.remove(ingredient)

    def __str__(self) -> str:
        """
        Returns a string representation of the Meal object.
        """
        nl = "\n- "
        return (
            f"{self._name} - {sum(ing._price for ing in self._ingredients)}€"
            f"{nl}{nl.join(str(ing) for ing in self._ingredients)}"
        )

if __name__ == "__main__":
    # Pizza Margherita
    pizza_dough = Ingredient("Pizza Dough", 260, "raw", "g", 1.15)
    tomato_sauce = Ingredient("Tomato Sauce", 200, "cooked", "g", 2.27)
    mozzarella = Ingredient("Mozzarella", 125, "raw", "g", 1.19)
    parmigiano = Ingredient("Parmigiano Reggiano", 60, "raw", "g", 1.83)
    basil = Ingredient("Fresh Basil", 30, "raw", "g", 1.4)

    pizza = Meal("Pizza Margherita")
    pizza.add_ingredient(pizza_dough)
    pizza.add_ingredient(tomato_sauce)
    pizza.add_ingredient(mozzarella)
    pizza.add_ingredient(parmigiano)
    pizza.add_ingredient(basil)

    print(pizza)