feat: added TimerValidator, validators_tests.py, errors.py; feat: updated ReadJson, custom_timer()

kawai_focus/screens/timer_screen.py

@@ -2,23 +2,22 @@ from kivy.uix.screenmanager import Screen
 from kivy.clock import Clock
 from kivy.core.audio import SoundLoader
 
-
-from kawai_focus.utils.utils import custom_timer
-from kawai_focus.utils.data_json import read_json_timer
+from kawai_focus.utils.utils import custom_timer, data_json
+from kawai_focus.utils.validators import TimerValidator
 
 
 class TimerScreen(Screen):
     """Экран таймера"""
 
-    sound_timer_name = read_json_timer.get_text('sound_timer')
+    sound_timer_name = data_json.get_text('sound_timer')
     path_file = f'sounds/{sound_timer_name}'
     sound = SoundLoader.load(path_file)
 
     def __init__(self, **kwargs):
         super(TimerScreen, self).__init__(**kwargs)
         # Переменные для управления таймером
-        self.zero_time = read_json_timer.get_text('zero_time')
-        self.timer_generator = None
+        self.zero_time = data_json.get_text('zero_time')
+        self.timer_generator = None 
         self.paused = False
         self.remaining_time = None
         self.sound_stop_event = None
@@ -30,7 +29,8 @@ class TimerScreen(Screen):
             self.paused = False
         else:
             # Инициализация генератора таймера
-            self.timer_generator = custom_timer(ss=12)  # Установите необходимое время
+            vaid_timer_data = TimerValidator(ss=12)  # Установите необходимое время
+            self.timer_generator = custom_timer(valid_data=vaid_timer_data)
             self.remaining_time = next(self.timer_generator, self.zero_time)
         
         # Запуск обновления времени каждую секунду
@@ -51,7 +51,7 @@ class TimerScreen(Screen):
         Clock.unschedule(self.update_time)
         self.paused = False
         # TODO: временное решение, время будет задаваться в интерфейсе
-        self.remaining_time = read_json_timer.get_text('custom_time')
+        self.remaining_time = data_json.get_text('custom_time')
         self.ids.time_label.text = self.remaining_time
 
         self.sound.stop()

kawai_focus/tests/validators_tests.py

@@ -0,0 +1,57 @@
+import pytest
+from kawai_focus.utils.errors import ErrorMessage
+from kawai_focus.utils.validators import TimerValidator
+
+
+def test_valid_time():
+    """Тест корректных данных"""
+    
+    timer = TimerValidator(hh=10, mm=30, ss=15)
+    assert timer.hh == 10
+    assert timer.mm == 30
+    assert timer.ss == 15
+
+
+def test_not_int_type():
+    """Тест исключения для некорректного типа данных"""
+    
+    with pytest.raises(TypeError) as excinfo:
+        TimerValidator(hh="10", mm=30, ss=15)
+    
+    assert str(excinfo.value) == ErrorMessage.NOT_INT_TYPE.value
+
+
+def test_no_time():
+    """Тест исключения ситуации когда не указано время"""
+    
+    with pytest.raises(ValueError) as excinfo:
+        TimerValidator(hh=0, mm=0, ss=0)
+    
+    assert str(excinfo.value) == ErrorMessage.NO_TIME.value
+
+
+def test_negative_time():
+    """Тест исключения для отрицательного времени"""
+    
+    with pytest.raises(ValueError) as excinfo:
+        TimerValidator(hh=-1, mm=30, ss=15)
+    
+    assert str(excinfo.value) == ErrorMessage.NEGATIVE_TIME.value
+
+
+def test_exceed_seconds_or_minutes():
+    """Тест исключения для секунд/минут больше 59"""
+    
+    with pytest.raises(ValueError) as excinfo:
+        TimerValidator(hh=0, mm=60, ss=10)
+    
+    assert str(excinfo.value) == ErrorMessage.SS_MM_BIG.value
+
+
+def test_exceed_hours():
+    """Тест исключения для часов больше 23"""
+    
+    with pytest.raises(ValueError) as excinfo:
+        TimerValidator(hh=24, mm=0, ss=0)
+    
+    assert str(excinfo.value) == ErrorMessage.HH_BIG.value

kawai_focus/utils/data_json.py

@@ -1,36 +0,0 @@
-import json
-
-from kawai_focus.main import Logger
-
-
-class ReadJson:
-    """Класс для чтения json файла"""
-
-    def __init__(self, file_name: str):
-        self.file_name = file_name
-        self.json_data = self.read_json_as_dict()
-
-    def read_json_as_dict(self) -> dict:
-        """Метод для чтения json файла как dict"""
-
-        try:
-            file_path = f'json/{self.file_name}'
-            with open(file=file_path, mode='r') as file:
-                return json.load(file)
-        except (FileNotFoundError, json.decoder.JSONDecodeError) as err:
-            Logger.error(f'Logger: {err.__class__.__name__}: {err}')
-
-    def get_text(self, name: str) -> str:
-        """Метод для возврата текста из файла json по ключу name"""
-        
-        text = self.json_data.get(name)
-        
-        if text:
-            if isinstance(text, list):
-                text = ''.join(text)
-                return text
-            return text
-
-
-read_json_err = ReadJson(file_name='errors.json')
-read_json_timer = ReadJson(file_name='timer.json')

kawai_focus/utils/errors.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+class ErrorMessage(Enum):
+    NO_TIME = 'Не указано время таймера!'
+    NEGATIVE_TIME = 'Время таймера не может быть отрицательным!'
+    SS_MM_BIG = 'Секунды и минуты не могут быть больше 59!'
+    HH_BIG = 'Часы не могут быть больше 23!'
+    FOLDER_NOT_FOUND = 'Папка не найдена!'
+    JSON_NOT_FOUND = 'Файл json не найден!'
+    TYPE_DICT = 'Тип данных не является словарем!'
+    NOT_INT_TYPE = 'Тип данных не является целым числом!'
+    KEY_ERROR = 'Ключ не найден!'

kawai_focus/utils/utils.py

@@ -1,30 +1,59 @@
 from typing import Generator
+import json
+from os import path, listdir
 
 from kawai_focus.main import Logger
-from kawai_focus.utils.data_json import read_json_err
+from kawai_focus.utils.errors import ErrorMessage
+from kawai_focus.utils.validators import TimerValidator
 
 
-def custom_timer(hh: int=0, mm: int=0, ss: int=0) -> Generator[str, None, None]:
+class ReadJson:
+    """Класс для чтения всех JSON-файлов в директории и объединения их в словарь."""
+
+    def __init__(self, folder_json: str):
+        self.folder_json = folder_json
+        self._json_data = self._read_all_json()
+
+    def _read_all_json(self) -> dict:
+        """Читает все JSON-файлы в директории и возвращает объединённый словарь."""
+        
+        if not path.exists(self.folder_json):
+            raise FileNotFoundError(ErrorMessage.FOLDER_NOT_FOUND.value)
+
+        # Получаем список всех файлов с расширением .json
+        json_files = [path.join(self.folder_json, file) for file in listdir(self.folder_json) if file.endswith('.json')]
+
+        if not json_files:
+            raise FileNotFoundError(ErrorMessage.JSON_NOT_FOUND.value)
+
+        data_dict = {}
+        
+        for file_path in json_files:
+            with open(file_path, 'r', encoding='utf-8') as file:
+                # Обновляем словарь с помощью .update() для эффективности
+                data_dict.update(json.load(file))
+
+        return data_dict
+
+    def get_text(self, name: str) -> str:
+        """Возвращает текст из словаря по ключу."""
+        
+        return self._json_data.get(name, ErrorMessage.KEY_ERROR.value)
+
+
+data_json = ReadJson(folder_json='json')
+
+
+def custom_timer(valid_data: TimerValidator) -> Generator[str, None, None]:
     """Функция отсчитывает время, установленное для таймера в формате 
     'hh:mm:ss'. Возвращает генератор, который возвращает текущее время
     в формате 'hh:mm:ss'."""
 
     try:
-        if ss == 0 and mm == 0 and hh == 0:
-            raise ValueError(read_json_err.get_text('no_time'))
-        
-        if ss < 0 or mm < 0 or hh < 0:
-            raise ValueError(read_json_err.get_text('negative_time'))
-
-        if ss > 59 or mm > 59:
-            raise ValueError(read_json_err.get_text('ss_mm_big'))
-        
-        if hh > 23:
-            raise ValueError(read_json_err.get_text('hh_big'))
-
-        total_seconds = (int(hh or 0) * 3600) + (int(mm or 0) * 60) + (int(ss or 0))
+        total_seconds = (int(valid_data.hh) * 3600) + (int(valid_data.mm) * 60) + (int(valid_data.ss))
 
         for remaining in range(total_seconds, -1, -1):
             yield f"{remaining // 3600:02d}:{(remaining % 3600) // 60:02d}:{remaining % 60:02d}"
     except (TypeError, ValueError) as err:
         Logger.error(f'Logger: {err.__class__.__name__}: {err}')
+    

kawai_focus/utils/validators.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+from kawai_focus.utils.errors import ErrorMessage 
+
+
+@dataclass
+class TimerValidator:
+    """Класс для валидации функции таймера."""
+
+    hh: int = 0
+    mm: int = 0
+    ss: int = 0
+
+    def __post_init__(self):
+        if not all(isinstance(value, int) for value in (self.hh, self.mm, self.ss)):
+            raise TypeError(ErrorMessage.NOT_INT_TYPE.value)
+
+        if self.ss == 0 and self.mm == 0 and self.hh == 0:
+            raise ValueError(ErrorMessage.NO_TIME.value)
+        
+        if self.ss < 0 or self.mm < 0 or self.hh < 0:
+            raise ValueError(ErrorMessage.NEGATIVE_TIME.value)
+
+        if self.ss > 59 or self.mm > 59:
+            raise ValueError(ErrorMessage.SS_MM_BIG.value)
+        
+        if self.hh > 23:
+            raise ValueError(ErrorMessage.HH_BIG.value)
+