Added Regular Exam

Author: MitkoVtori

OOP/E.Regular Exam/Structure and Functionality/project.zip

@@ -0,0 +1,48 @@
+from abc import ABC, abstractmethod
+
+
+class BaseRobot(ABC):
+
+    def __init__(self, name: str, kind: str, price: float, weight: int):
+        self.name = name
+        self.kind = kind
+        self.price = price
+        self.weight = weight
+
+    @property
+    def name(self):
+        return self.__name
+
+    @name.setter
+    def name(self, value):
+        if value.rstrip() == "":
+            raise ValueError("Robot name cannot be empty!")
+
+        self.__name = value
+
+    @property
+    def kind(self):
+        return self.__kind
+
+    @kind.setter
+    def kind(self, value):
+        if value.rstrip() == "":
+            raise ValueError("Robot kind cannot be empty!")
+
+        self.__kind = value
+
+    @property
+    def price(self):
+        return self.__price
+
+    @price.setter
+    def price(self, value):
+        if value <= 0:
+            raise ValueError("Robot price cannot be less than or equal to 0.0!")
+
+        self.__price = value
+
+    @abstractmethod
+    def eating(self):
+        pass
+

OOP/E.Regular Exam/# TODO.txt renamed to OOP/E.Regular Exam/Structure and Functionality/project/robots/__init__.py

@@ -0,0 +1,12 @@
+from project.robots.base_robot import BaseRobot
+
+
+class FemaleRobot(BaseRobot):
+
+    def __init__(self, name: str, kind: str, price: float):
+        weight: int = 7
+        super().__init__(name, kind, price, weight)
+
+    def eating(self):
+        self.weight += 1
+

OOP/E.Regular Exam/Structure and Functionality/project/robots/base_robot.py

@@ -0,0 +1,12 @@
+from project.robots.base_robot import BaseRobot
+
+
+class MaleRobot(BaseRobot):
+
+    def __init__(self, name: str, kind: str, price: float):
+        weight: int = 9
+        super().__init__(name, kind, price, weight)
+
+    def eating(self):
+        self.weight += 3
+

OOP/E.Regular Exam/Structure and Functionality/project/robots/female_robot.py

@@ -0,0 +1,82 @@
+from project.services.main_service import MainService
+from project.services.secondary_service import SecondaryService
+from project.robots.male_robot import MaleRobot
+from project.robots.female_robot import FemaleRobot
+
+
+class RobotsManagingApp:
+
+    def __init__(self):
+        self.robots = [] # objects
+        self.services = [] # objects
+
+    def add_service(self, service_type: str, name: str):
+        if service_type not in ["MainService", "SecondaryService"]:
+            raise Exception("Invalid service type!")
+
+        if service_type == "MainService":
+            service = MainService(name)
+
+        else:
+            service = SecondaryService(name)
+
+        self.services.append(service)
+        return f"{service_type} is successfully added."
+
+    def add_robot(self, robot_type: str, name: str, kind: str, price: float):
+        if robot_type not in ["MaleRobot", "FemaleRobot"]:
+            raise Exception("Invalid robot type!")
+
+        if robot_type == "MaleRobot":
+            robot = MaleRobot(name, kind, price)
+
+        else:
+            robot = FemaleRobot(name, kind, price)
+
+        self.robots.append(robot)
+        return f"{robot_type} is successfully added."
+
+    def add_robot_to_service(self, robot_name: str, service_name: str):
+        robot = [x for x in self.robots if x.name == robot_name][0]
+        service = [x for x in self.services if x.name == service_name][0]
+
+        if isinstance(robot, MaleRobot) and isinstance(service, SecondaryService):
+            return "Unsuitable service."
+
+        if isinstance(robot, FemaleRobot) and isinstance(service, MainService):
+            return "Unsuitable service."
+
+        if len(service.robots) >= service.capacity:
+            raise Exception("Not enough capacity for this robot!")
+
+        self.robots.remove(robot)
+        service.robots.append(robot)
+        return f"Successfully added {robot_name} to {service_name}."
+
+    def remove_robot_from_service(self, robot_name: str, service_name: str):
+        service = [x for x in self.services if x.name == service_name][0]
+        if robot_name not in [x.name for x in service.robots]:
+            raise Exception("No such robot in this service!")
+
+        robot = [x for x in service.robots if x.name == robot_name][0]
+        service.robots.remove(robot)
+        self.robots.append(robot)
+        return f"Successfully removed {robot_name} from {service_name}."
+
+    def feed_all_robots_from_service(self, service_name: str):
+        service = [x for x in self.services if x.name == service_name][0]
+        for robot in service.robots:
+            robot.eating()
+
+        return f"Robots fed: {len(service.robots)}."
+
+    def service_price(self, service_name: str):
+        service = [x for x in self.services if x.name == service_name][0]
+        total_sum = 0
+        for robot in service.robots:
+            total_sum += robot.price
+        return f"The value of service {service_name} is {total_sum:.2f}."
+
+    def __str__(self):
+        return '\n'.join([x.details() for x in self.services])
+

OOP/E.Regular Exam/Structure and Functionality/project/robots/male_robot.py

@@ -0,0 +1,36 @@
+from abc import ABC, abstractmethod
+
+
+class BaseService(ABC):
+
+    def __init__(self, name: str, capacity: int):
+        self.name = name
+        self.capacity = capacity
+        self.robots = [] # robot objects
+
+    @property
+    def name(self):
+        return self.__name
+
+    @name.setter
+    def name(self, value):
+        if value.rstrip() == "":
+            raise ValueError("Service name cannot be empty!")
+
+        self.__name = value
+
+    @property
+    def capacity(self):
+        return self.__capacity
+
+    @capacity.setter
+    def capacity(self, value):
+        if value <= 0:
+            raise ValueError("Service capacity cannot be less than or equal to 0!")
+
+        self.__capacity = value
+
+    @abstractmethod
+    def details(self):
+        pass
+

OOP/E.Regular Exam/Structure and Functionality/project/robots_managing_app.py

@@ -0,0 +1,12 @@
+from project.services.base_service import BaseService
+
+
+class MainService(BaseService):
+
+    def __init__(self, name: str):
+        capacity: int=30
+        super().__init__(name, capacity)
+
+    def details(self):
+        return f"{self.name} Main Service:\nRobots: {' '.join([x.name for x in self.robots]) if self.robots else 'none'}"
+

OOP/E.Regular Exam/Structure and Functionality/project/services/__init__.py

@@ -0,0 +1,12 @@
+from project.services.base_service import BaseService
+
+
+class SecondaryService(BaseService):
+
+    def __init__(self, name: str):
+        capacity: int=15
+        super().__init__(name, capacity)
+
+    def details(self):
+        return f"{self.name} Secondary Service:\nRobots: {' '.join([x.name for x in self.robots]) if self.robots else 'none'}"
+

OOP/E.Regular Exam/Structure and Functionality/project/services/base_service.py

@@ -0,0 +1,62 @@
+from unittest import TestCase, main
+from project.tennis_player import TennisPlayer
+
+
+class TestTennisPlayer(TestCase):
+
+    def setUp(self) -> None:
+        self.tennis_player = TennisPlayer("Dimitar", 19, 7)
+
+    def test_successful_initialization(self):
+        self.assertEqual("Dimitar", self.tennis_player.name)
+        self.assertEqual(19, self.tennis_player.age)
+        self.assertEqual(7, self.tennis_player.points)
+        self.assertEqual([], self.tennis_player.wins)
+
+    def test_invalid_name(self):
+        with self.assertRaises(ValueError) as ve:
+            self.tennis_player = TennisPlayer("g", 20, 8)
+
+        self.assertEqual("Name should be more than 2 symbols!", str(ve.exception))
+
+        with self.assertRaises(ValueError) as ve:
+            self.tennis_player = TennisPlayer("gg", 20, 8)
+
+        self.assertEqual("Name should be more than 2 symbols!", str(ve.exception))
+
+    def test_invalid_age(self):
+        with self.assertRaises(ValueError) as ve:
+            self.tennis_player = TennisPlayer("George", 4, 17)
+
+        self.assertEqual("Players must be at least 18 years of age!", str(ve.exception))
+
+    def test_unsuccessful_add_new_win(self):
+        self.tennis_player.wins = ["Le copa Italia"]
+        result = self.tennis_player.add_new_win("Le copa Italia")
+        self.assertEqual(f"Le copa Italia has been already added to the list of wins!", result)
+
+    def test_successful_add_new_win(self):
+        self.tennis_player.add_new_win("Golden Years")
+        self.assertEqual("Golden Years", self.tennis_player.wins[0])
+
+    def test_less_than_False(self):
+        second_player = TennisPlayer("Gorge", 21, 4)
+        result = self.tennis_player < second_player
+        self.assertEqual(f'Dimitar is a better player than Gorge', result)
+
+    def test_less_than_True(self):
+        second_player = TennisPlayer("Gorge", 21, 17)
+        result = self.tennis_player < second_player
+        self.assertEqual(f'Gorge is a top seeded player and he/she is better than Dimitar', result)
+
+    def test_string_return(self):
+        self.tennis_player.wins = ["Le copa Italia", "Golden Years 2nd edition"]
+        result = f"Tennis Player: Dimitar\n" \
+                 f"Age: 19\n" \
+                 f"Points: 7.0\n" \
+                 f"Tournaments won: Le copa Italia, Golden Years 2nd edition"
+        self.assertEqual(result, str(self.tennis_player))
+
+
+if __name__ == '__main__':
+    main()