- replaced imports as modules with import only necessary variables

- spelling fixes

.gitignore

@@ -1,3 +1,4 @@
 __pycache__/
 .pytest_cache/
-.vscode/
+.vscode/
+.venv/

requirements.txt

@@ -0,0 +1,13 @@
+astroid==2.12.12
+autopep8==2.0.0
+dill==0.3.6
+isort==5.10.1
+lazy-object-proxy==1.8.0
+mccabe==0.7.0
+mock==4.0.3
+platformdirs==2.5.2
+pycodestyle==2.9.1
+pylint==2.15.5
+tomli==2.0.1
+tomlkit==0.11.6
+wrapt==1.14.1

src/layers/model/constants.py

@@ -1,10 +1,11 @@
-from . import types
+from .types import State, GameStages
+
 
 DECK = [2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 6, 6, 6, 6, 7, 7,
         7, 7, 8, 8, 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11]
-INITIAL_STATE: types.State = {
+INITIAL_STATE: State = {
     'game': {
-        'stage': types.GameStages.STARTING_IS_AWAITED.value,
+        'stage': GameStages.STARTING_IS_AWAITED.value,
         'deck': DECK.copy(),
         'bank': 0,
         'winner': None,

src/layers/model/model.py

@@ -1,62 +1,63 @@
 import copy
 import random
 
-from observable import observable
-from savings import savings
+from observable.observable import Observable
+from savings.savings import Savings
 
-from . import constants, types
+from .constants import INITIAL_STATE, WIN_SCORE, MAX_CARDS_NUMBER_ON_HAND
+from .types import State, GameStages, EventNames, PlayerNames, PlayerName
 
 
-class Model(observable.Observable):
-    _state: types.State
-    _savings: savings.Savings
+class Model(Observable):
+    _state: State
+    _savings: Savings
 
-    def __init__(self, savings_instance: savings.Savings) -> None:
+    def __init__(self, savings: Savings) -> None:
         super().__init__()
 
-        self._savings = savings_instance
+        self._savings = savings
         saving = self._savings.load()
 
         self._state = saving if saving else copy.deepcopy(
-            constants.INITIAL_STATE)
+            INITIAL_STATE)
 
-    def get_state(self) -> types.State:
+    def get_state(self) -> State:
         return self._state
 
     def start_game(self) -> None:
         is_player_broke = self._state['statistics']['player']['money'] == 0
-        self._state['game']['stage'] = types.GameStages.DEPOSIT_IS_AWAITED.value if is_player_broke else types.GameStages.BET_IS_AWAITED.value
+        self._state['game']['stage'] = GameStages.DEPOSIT_IS_AWAITED.value if is_player_broke else GameStages.BET_IS_AWAITED.value
 
         self._savings.save(self._state)
-        self._emit(types.EventNames.STATE_UPDATED.value, self._state)
+        self._emit(EventNames.STATE_UPDATED.value, self._state)
 
     def add_money_to_player(self, amount: int) -> None:
         if amount:
             self._state['statistics']['player']['money'] += amount
-            self._state['game']['stage'] = types.GameStages.BET_IS_AWAITED.value
+            self._state['game']['stage'] = GameStages.BET_IS_AWAITED.value
         else:
             self._make_first_hand()
-            self._state['game']['stage'] = types.GameStages.CARD_TAKING_IS_AWAITED.value
+            self._state['game']['stage'] = GameStages.CARD_TAKING_IS_AWAITED.value
 
         self._savings.save(self._state)
-        self._emit(types.EventNames.STATE_UPDATED.value, self._state)
+        self._emit(EventNames.STATE_UPDATED.value, self._state)
 
     def make_bet_for_player(self, amount: int) -> None:
         if amount:
             self._state['statistics']['player']['money'] -= amount
             self._state['game']['bank'] = amount * 2
 
         self._make_first_hand()
-        self._state['game']['stage'] = types.GameStages.CARD_TAKING_IS_AWAITED.value
+        self._state['game']['stage'] = GameStages.CARD_TAKING_IS_AWAITED.value
         self._savings.save(self._state)
-        self._emit(types.EventNames.STATE_UPDATED.value, self._state)
+        self._emit(EventNames.STATE_UPDATED.value, self._state)
 
     def issue_card_to_player(self) -> None:
-        self._issue_card(types.PlayerNames.PLAYER.value)
+        self._issue_card(PlayerNames.PLAYER.value)
 
-        if self._check_can_player_take_card(types.PlayerNames.PLAYER.value):
+        if self._check_can_player_take_card(PlayerNames.PLAYER.value):
             self._savings.save(self._state)
-            self._emit(types.EventNames.STATE_UPDATED.value, self._state)
+            self._emit(EventNames.STATE_UPDATED.value, self._state)
         else:
             self.finish_game()
 
@@ -69,29 +70,29 @@ def finish_game(self) -> None:
         if self._state['game']['bank']:
             self._distribute_winnings()
 
-        self._state['game']['stage'] = types.GameStages.FINISHED.value
+        self._state['game']['stage'] = GameStages.FINISHED.value
         self._savings.save(self._state)
-        self._emit(types.EventNames.STATE_UPDATED.value, self._state)
+        self._emit(EventNames.STATE_UPDATED.value, self._state)
 
     def restart_game(self) -> None:
         if self._state['game']['winner']:
             self._state['game']['winner'] = None
 
-        self._take_cards_from_player(types.PlayerNames.COMPUTER.value)
-        self._take_cards_from_player(types.PlayerNames.PLAYER.value)
+        self._take_cards_from_player(PlayerNames.COMPUTER.value)
+        self._take_cards_from_player(PlayerNames.PLAYER.value)
         self.start_game()
 
     def _make_first_hand(self) -> None:
         self._issue_cards_to_computer()
-        self._issue_card(types.PlayerNames.PLAYER.value)
-        self._issue_card(types.PlayerNames.PLAYER.value)
+        self._issue_card(PlayerNames.PLAYER.value)
+        self._issue_card(PlayerNames.PLAYER.value)
 
     def _issue_cards_to_computer(self) -> None:
-        self._issue_card(types.PlayerNames.COMPUTER.value)
-        self._issue_card(types.PlayerNames.COMPUTER.value)
+        self._issue_card(PlayerNames.COMPUTER.value)
+        self._issue_card(PlayerNames.COMPUTER.value)
 
-        while self._check_can_player_take_card(types.PlayerNames.COMPUTER.value) and self._decide_whether_to_take_card_to_computer():
-            self._issue_card(types.PlayerNames.COMPUTER.value)
+        while self._check_can_player_take_card(PlayerNames.COMPUTER.value) and self._decide_whether_to_take_card_to_computer():
+            self._issue_card(PlayerNames.COMPUTER.value)
 
     def _decide_whether_to_take_card_to_computer(self) -> bool:
         computer_score = self._state['game']['computer']['score']
@@ -104,26 +105,26 @@ def _decide_whether_to_take_card_to_computer(self) -> bool:
 
         return random.choice((True, False))
 
-    def _issue_card(self, player_name: types.PlayerName) -> None:
+    def _issue_card(self, player_name: PlayerName) -> None:
         card = self._state['game']['deck'].pop(
             random.randrange(0, len(self._state['game']['deck'])))
 
         self._state['game'][player_name]['deck'].append(card)
         self._state['game'][player_name]['score'] += card
 
-    def _determine_winner(self) -> types.PlayerName | None:
+    def _determine_winner(self) -> PlayerName | None:
         skynet_score = self._state['game']['computer']['score']
         player_score = self._state['game']['player']['score']
 
         if skynet_score == player_score:
             return None
 
         is_computer_score_closer_to_win_score = abs(
-            skynet_score - constants.WIN_SCORE) < abs(player_score - constants.WIN_SCORE)
+            skynet_score - WIN_SCORE) < abs(player_score - WIN_SCORE)
 
-        return types.PlayerNames.COMPUTER.value if is_computer_score_closer_to_win_score else types.PlayerNames.PLAYER.value
+        return PlayerNames.COMPUTER.value if is_computer_score_closer_to_win_score else PlayerNames.PLAYER.value
 
-    def _take_cards_from_player(self, player_name: types.PlayerName) -> None:
+    def _take_cards_from_player(self, player_name: PlayerName) -> None:
         self._state['game']['deck'].extend(
             self._state['game'][player_name]['deck'])
         self._state['game'][player_name]['deck'].clear()
@@ -133,7 +134,7 @@ def _distribute_winnings(self) -> None:
         bank = self._state['game']['bank']
         winner = self._state['game']['winner']
 
-        if winner == types.PlayerNames.PLAYER.value:
+        if winner == PlayerNames.PLAYER.value:
             self._state['statistics']['player']['money'] += bank
 
         if not winner:
@@ -142,6 +143,6 @@ def _distribute_winnings(self) -> None:
 
         self._state['game']['bank'] = 0
 
-    def _check_can_player_take_card(self, player_name: types.PlayerName) -> bool:
+    def _check_can_player_take_card(self, player_name: PlayerName) -> bool:
         return len(
-            self._state['game'][player_name]['deck']) < constants.MAX_CARDS_NUMBER_ON_HAND
+            self._state['game'][player_name]['deck']) < MAX_CARDS_NUMBER_ON_HAND

src/layers/presenter/presenter.py

@@ -1,30 +1,32 @@
-from layers.view import view, types as view_types
-from layers.model import model, types as model_types
+from layers.view.view import View
+from layers.view.types import EventNames as ViewEventNames
+from layers.model.model import Model
+from layers.model.types import State, EventNames as ModelEventNames
 
 
 class Presenter():
-    _view: view.View
-    _model: model.Model
+    _view: View
+    _model: Model
 
-    def __init__(self, view_instance: view.View, model_instance: model.Model) -> None:
-        self._view = view_instance
+    def __init__(self, view: View, model: Model) -> None:
+        self._view = view
         self._subscribe_to_view_events()
 
-        self._model = model_instance
+        self._model = model
         self._subscribe_to_model_events()
 
     def _subscribe_to_view_events(self) -> None:
-        self._view.on(view_types.EventNames.GAME_STARTED.value,
+        self._view.on(ViewEventNames.GAME_STARTED.value,
                       self._handle_game_start)
-        self._view.on(view_types.EventNames.MONEY_DEPOSITED.value,
+        self._view.on(ViewEventNames.MONEY_DEPOSITED.value,
                       self._handle_money_deposit)
-        self._view.on(view_types.EventNames.BET_MADE.value,
+        self._view.on(ViewEventNames.BET_MADE.value,
                       self._handle_bet_make)
-        self._view.on(view_types.EventNames.CARD_TAKEN.value,
+        self._view.on(ViewEventNames.CARD_TAKEN.value,
                       self._handle_card_take)
-        self._view.on(view_types.EventNames.CARD_REJECTED.value,
+        self._view.on(ViewEventNames.CARD_REJECTED.value,
                       self._handle_card_reject)
-        self._view.on(view_types.EventNames.GAME_RESTARTED.value,
+        self._view.on(ViewEventNames.GAME_RESTARTED.value,
                       self._handle_game_restart)
 
     def _handle_game_start(self) -> None:
@@ -46,8 +48,8 @@ def _handle_game_restart(self) -> None:
         self._model.restart_game()
 
     def _subscribe_to_model_events(self) -> None:
-        self._model.on(model_types.EventNames.STATE_UPDATED.value,
+        self._model.on(ModelEventNames.STATE_UPDATED.value,
                        self._handle_state_update)
 
-    def _handle_state_update(self, state: model_types.State) -> None:
+    def _handle_state_update(self, state: State) -> None:
         self._view.update(state)

src/layers/view/constants.py

@@ -15,7 +15,7 @@
 - Если сумма в банке является нечетным числом и результат игры - ничья, то не пугайся, выигрыш делится на двоих, затем округляется в меньшую сторону, а остаток идет на благотворительность
 '''
 }
-REQUESTS = {
+REQUEST_TEXTS = {
     'try_luck': 'Попытать удачу? [y/n] ',
     'deposit': 'Упс, кажется ты проиграл все свои деньги. Укажи, сколько нам списать с твоей карты *2144 (или 0, если хочешь поиграть на очки): ',
     'one_more_card': 'Возьмем еще карту? [y/n] ',