hw

.github/workflows/check-solutions.yaml

@@ -27,12 +27,16 @@ jobs:
 
     - name: Lint code
       run: |
-        ruff check ./solutions
+        ruff check ./solutions ./homeworks
 
     - name: Check code format
       run: |
-        ruff format --check ./solutions
+        ruff format --check ./solutions ./homeworks
 
-    - name: Test code
+    - name: Test code 
       run: |
         pytest -v --cov=./solutions ./tests/
+
+    - name: Test code hw
+      run: |
+        pytest -v --cov=./homeworks ./tests_hw/

homeworks/hw1/aggregate_segmentation.py

@@ -0,0 +1,28 @@
+ALLOWED_TYPES = {
+    "spotter_word",
+    "voice_human",
+    "voice_bot",
+}
+
+
+def aggregate_segmentation(
+    segmentation_data: list[dict[str, str | float | None]],
+) -> tuple[dict[str, dict[str, dict[str, str | float]]], list[str]]:
+    """
+    Функция для валидации и агрегации данных разметки аудио сегментов.
+
+    Args:
+        segmentation_data: словарь, данные разметки аудиосегментов с полями:
+            "audio_id" - уникальный идентификатор аудио.
+            "segment_id" - уникальный идентификатор сегмента.
+            "segment_start" - время начала сегмента.
+            "segment_end" - время окончания сегмента.
+            "type" - тип голоса в сегменте.
+
+    Returns:
+        Словарь с валидными сегментами, объединёнными по `audio_id`;
+        Список `audio_id` (str), которые требуют переразметки.
+    """
+
+    # ваш код
+    return {}, []

homeworks/hw1/backoff.py

@@ -0,0 +1,38 @@
+from random import uniform
+from time import sleep
+from typing import (
+    Callable,
+    ParamSpec,
+    TypeVar,
+)
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def backoff(
+    retry_amount: int = 3,
+    timeout_start: float = 0.5,
+    timeout_max: float = 10.0,
+    backoff_scale: float = 2.0,
+    backoff_triggers: tuple[type[Exception]] = (Exception,),
+) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    """
+    Параметризованный декоратор для повторных запусков функций.
+
+    Args:
+        retry_amount: максимальное количество попыток выполнения функции;
+        timeout_start: начальное время ожидания перед первой повторной попыткой (в секундах);
+        timeout_max: максимальное время ожидания между попытками (в секундах);
+        backoff_scale: множитель, на который увеличивается задержка после каждой неудачной попытки;
+        backoff_triggers: кортеж типов исключений, при которых нужно выполнить повторный вызов.
+
+    Returns:
+        Декоратор для непосредственного использования.
+
+    Raises:
+        ValueError, если были переданы невозможные аргументы.
+    """
+
+    # ваш код
+    pass

homeworks/hw1/cache.py

@@ -0,0 +1,27 @@
+from typing import (
+    Callable,
+    ParamSpec,
+    TypeVar,
+)
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def lru_cache(capacity: int) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    """
+    Параметризованный декоратор для реализации LRU-кеширования.
+
+    Args:
+        capacity: целое число, максимальный возможный размер кеша.
+
+    Returns:
+        Декоратор для непосредственного использования.
+
+    Raises:
+        TypeError, если capacity не может быть округлено и использовано
+            для получения целого числа.
+        ValueError, если после округления capacity - число, меньшее 1.
+    """
+    # ваш код
+    pass

homeworks/hw1/convert_exception.py

@@ -0,0 +1,28 @@
+from typing import (
+    Callable,
+    ParamSpec,
+    TypeVar,
+)
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def convert_exceptions_to_api_compitable_ones(
+    exception_to_api_exception: dict[type[Exception], type[Exception] | Exception],
+) -> Callable[[Callable[P, R]], Callable[P, R]]:
+    """
+    Параметризованный декоратор для замены внутренних исключений на API-исключении.
+
+    Args:
+        exception_to_api_exception: словарь:
+            ключи - внутренние исключения, которые надо заменить,
+            значения - API-исключения, которые надо возбудить
+                вместо внутренних исключений
+
+    Returns:
+        Декоратор для непосредственного использования.
+    """
+
+    # ваш код
+    pass

tests_hw/hw1_test_data/cache_test_data.py

@@ -0,0 +1,166 @@
+TESTCASE_DATA = (
+    (
+        1,
+        [
+            ((), {}),
+            ((), {}),
+            ((), {}),
+        ],
+        1,
+    ),
+    (
+        1,
+        [
+            ((1, 2), {"a": 3}),
+            ((1, 2), {"a": 3}),
+            ((1, 2), {"a": 3}),
+        ],
+        1,
+    ),
+    (
+        1,
+        [
+            ((1, 2), {}),
+            ((1, 2, 3), {}),
+            ((1, 2), {}),
+            ((1, 2, 3), {}),
+        ],
+        4,
+    ),
+    (
+        3,
+        [
+            ((1, 2), {"a": 3}),
+            ((1, 2), {"a": 3}),
+            ((1, 2), {"a": 3}),
+        ],
+        1,
+    ),
+    (
+        3,
+        [
+            ((1, 2), {}),
+            ((1, 2, 3), {}),
+            ((1, 2), {"a": 3}),
+            ((1, 2), {}),
+            ((1, 2, 3), {}),
+            ((1, 2), {"a": 3}),
+            ((1, 2), {}),
+            ((1, 2, 3), {}),
+            ((1, 2), {"a": 3}),
+        ],
+        3,
+    ),
+    (
+        3,
+        [
+            ((1, 2), {}),
+            ((1, 2, 3), {}),
+            ((1, 2), {"a": 3}),
+            ((1, 2), {}),
+            ((1, 2, 3), {}),
+            ((1, 2), {"a": 3}),
+            ((1,), {"c": 4}),
+            ((1, 2), {}),
+            ((1, 2, 3), {}),
+            ((1, 2), {"a": 3}),
+        ],
+        7,
+    ),
+    (
+        3,
+        [
+            ((1, 2), {}),
+            ((1, 2, 3), {}),
+            ((1, 2), {"a": 3}),
+            ((1,), {"a": 1, "b": 2}),
+            ((1,), {"a": 1, "c": 3}),
+            ((1, 2), {}),
+        ],
+        6,
+    ),
+    (
+        3,
+        [
+            ((1, 1), {}),
+            ((1, 1), {}),
+            ((1, 1), {}),
+            ((2, 2), {}),
+            ((2, 2), {}),
+            ((2, 2), {}),
+            ((3, 3), {}),
+            ((3, 3), {}),
+            ((3, 3), {}),
+        ],
+        3,
+    ),
+    (
+        3,
+        [
+            (("a", "a"), {}),
+            (("b", "b"), {}),
+            (("c", "c"), {}),
+            (("a", "a"), {}),
+            (("d", "d"), {}),
+            (("e", "e"), {}),
+            (("a", "a"), {}),
+            (("b", "b"), {}),
+            (("c", "c"), {}),
+            (("a", "a"), {}),
+        ],
+        7,
+    ),
+    (
+        5,
+        [
+            ((), {"a": "a"}),
+            ((), {"b": "b"}),
+            ((), {"c": "c"}),
+            ((), {"d": "d"}),
+            ((), {"e": "e"}),
+            ((), {"c": "c"}),
+            ((), {"f": "f"}),
+            ((), {"g": "g"}),
+            ((), {"c": "c"}),
+            ((), {"a": "a"}),
+            ((), {"b": "b"}),
+            ((), {"d": "d"}),
+            ((), {"e": "e"}),
+            ((), {"f": "f"}),
+            ((), {"c": "c"}),
+        ],
+        13,
+    ),
+    (
+        3,
+        [
+            ((1, 2), {"a": "a", "b": "b", "c": "c"}),
+            ((1, 2), {"b": "b", "c": "c", "a": "a"}),
+            ((1, 2), {"c": "c", "a": "a", "b": "b"}),
+        ],
+        1,
+    ),
+    (
+        3,
+        [
+            ((1, 2, 3), {"a": "a", "b": "b", "c": "c"}),
+            ((3, 1, 2), {"b": "b", "c": "c", "a": "a"}),
+            ((2, 3, 1), {"c": "c", "a": "a", "b": "b"}),
+        ],
+        3,
+    ),
+)
+TESTCASE_IDS = (
+    "cap-1-empty-input-several-calls",
+    "cap-1-same-calls",
+    "cap-1-pair-of-different-calls",
+    "cap-3-all-same-calls",
+    "cap-3-same-triplet-calls",
+    "cap-3-same-triplet-then-pop",
+    "cap-3-different-calls",
+    "cap-3-most-top-touch",
+    "cap-3-most-bottom-touch",
+    "cap-5-middle-touch",
+    "cap-3-kwards-sort",
+    "cap-3-positional-ordering",
+)