diff --git a/deprecated_tests/sem01/tests/test_lesson02_tasks.py b/deprecated_tests/sem01/tests/test_lesson02_tasks.py
index f11403f4..b7febe4b 100644
--- a/deprecated_tests/sem01/tests/test_lesson02_tasks.py
+++ b/deprecated_tests/sem01/tests/test_lesson02_tasks.py
@@ -10,7 +10,7 @@
 
 
 @pytest.mark.parametrize(
-    "num, result_expected", 
+    "num, result_expected",
     (
         pytest.param(
             0,
@@ -44,7 +44,7 @@ def test_get_factorial(num: int, result_expected: int) -> None:
 
 
 @pytest.mark.parametrize(
-    "num, result_expected", 
+    "num, result_expected",
     (
         pytest.param(
             0,
@@ -83,7 +83,7 @@ def test_get_doubled_factorial(num: int, result_expected: int) -> None:
 
 
 @pytest.mark.parametrize(
-    "num, result_expected", 
+    "num, result_expected",
     (
         pytest.param(
             1,
@@ -125,7 +125,7 @@ def test_get_amount_of_ways_to_climb(
 
 
 @pytest.mark.parametrize(
-    "num, result_expected", 
+    "num, result_expected",
     (
         pytest.param(
             1,
@@ -162,7 +162,7 @@ def test_get_multiplications_amount(
 
 
 @pytest.mark.parametrize(
-    "num1, num2, result_expected", 
+    "num1, num2, result_expected",
     (
         pytest.param(
             1,
@@ -229,7 +229,7 @@ def test_get_gcd(
 
 
 @pytest.mark.parametrize(
-    "num, result_expected", 
+    "num, result_expected",
     (
         pytest.param(
             1,
@@ -273,10 +273,10 @@ def test_get_sum_of_prime_divisors(num: int, result_expected: int) -> None:
 
 
 @pytest.mark.parametrize(
-    "num, result_expected", 
+    "num, result_expected",
     (
         pytest.param(
-            -10**10,
+            -(10**10),
             False,
             id="negative-ten-billion",
         ),
diff --git a/deprecated_tests/sem01/tests/test_lesson04_tasks.py b/deprecated_tests/sem01/tests/test_lesson04_tasks.py
index 4110bdcc..c98b6f22 100644
--- a/deprecated_tests/sem01/tests/test_lesson04_tasks.py
+++ b/deprecated_tests/sem01/tests/test_lesson04_tasks.py
@@ -1,6 +1,7 @@
-import pytest 
 import random
 
+import pytest
+
 from solutions.sem01.lesson04.task1 import is_arithmetic_progression
 from solutions.sem01.lesson04.task2 import merge_intervals
 from solutions.sem01.lesson04.task3 import find_single_number
@@ -8,62 +9,89 @@
 from solutions.sem01.lesson04.task5 import find_row_with_most_ones
 from solutions.sem01.lesson04.task6 import count_cycles
 
-@pytest.mark.parametrize("lst, expected", [
-    pytest.param([], True, id="empty_list"),
-    pytest.param([5], True, id="single_element"),
-    pytest.param([1, 3], True, id="two_elements"),
-    pytest.param([3, 1], True, id="two_elements_unsorted"),
-    pytest.param([1, 3, 5, 7], True, id="already_sorted_ap"),
-    pytest.param([3, 1, 5, 7], True, id="unsorted_ap"),
-    pytest.param([1, 2, 4], False, id="not_ap"),
-    pytest.param([10, 5, 0, -5], True, id="negative_difference"),
-    pytest.param([1, 1, 1, 1], True, id="constant_sequence"),
-    pytest.param([1, 2, 3, 5], False, id="almost_ap_but_not"),
-    pytest.param([0, 0, 1], False, id="two_same_one_different"),
-    pytest.param([10**5 + i*10**2 for i in range(1000)], True, id="long_list_true"),
-    pytest.param([10**5 + i*10**2 for i in range(999)] + [1], False, id="long_list_false"),
-])
+
+@pytest.mark.parametrize(
+    "lst, expected",
+    [
+        pytest.param([], True, id="empty_list"),
+        pytest.param([5], True, id="single_element"),
+        pytest.param([1, 3], True, id="two_elements"),
+        pytest.param([3, 1], True, id="two_elements_unsorted"),
+        pytest.param([1, 3, 5, 7], True, id="already_sorted_ap"),
+        pytest.param([3, 1, 5, 7], True, id="unsorted_ap"),
+        pytest.param([1, 2, 4], False, id="not_ap"),
+        pytest.param([10, 5, 0, -5], True, id="negative_difference"),
+        pytest.param([1, 1, 1, 1], True, id="constant_sequence"),
+        pytest.param([1, 2, 3, 5], False, id="almost_ap_but_not"),
+        pytest.param([0, 0, 1], False, id="two_same_one_different"),
+        pytest.param([10**5 + i * 10**2 for i in range(1000)], True, id="long_list_true"),
+        pytest.param([10**5 + i * 10**2 for i in range(999)] + [1], False, id="long_list_false"),
+    ],
+)
 def test_is_arithmetic_progression_parametrized(lst, expected):
     if len(lst) > 500:
         random.shuffle(lst)
     assert is_arithmetic_progression(lst) == expected
 
 
-@pytest.mark.parametrize("intervals, expected", [
-    pytest.param([], [], id="empty"),
-    pytest.param([[1, 3]], [[1, 3]], id="single_interval"),
-    pytest.param([[10, 13], [1, 3], [2, 6], [8, 10], [15, 18]], [[1, 6], [8, 13], [15, 18]], id="classic_merge"),
-    pytest.param([[1, 4], [4, 5]], [[1, 5]], id="touching_intervals"),
-    pytest.param([[1, 4], [2, 3]], [[1, 4]], id="nested_interval"),
-    pytest.param([[5, 7], [1, 3], [15, 20], [0, 0], [2, 4], [6, 10], [0, 2]], [[0, 4], [5, 10], [15, 20]], id="unsorted_input"),
-    pytest.param([[1, 2], [3, 4], [5, 6]], [[1, 2], [3, 4], [5, 6]], id="no_overlap"),
-    pytest.param([[1, 10], [2, 3], [4, 5], [6, 7]], [[1, 10]], id="all_merged"),
-])
+@pytest.mark.parametrize(
+    "intervals, expected",
+    [
+        pytest.param([], [], id="empty"),
+        pytest.param([[1, 3]], [[1, 3]], id="single_interval"),
+        pytest.param(
+            [[10, 13], [1, 3], [2, 6], [8, 10], [15, 18]],
+            [[1, 6], [8, 13], [15, 18]],
+            id="classic_merge",
+        ),
+        pytest.param([[1, 4], [4, 5]], [[1, 5]], id="touching_intervals"),
+        pytest.param([[1, 4], [2, 3]], [[1, 4]], id="nested_interval"),
+        pytest.param(
+            [[5, 7], [1, 3], [15, 20], [0, 0], [2, 4], [6, 10], [0, 2]],
+            [[0, 4], [5, 10], [15, 20]],
+            id="unsorted_input",
+        ),
+        pytest.param([[1, 2], [3, 4], [5, 6]], [[1, 2], [3, 4], [5, 6]], id="no_overlap"),
+        pytest.param([[1, 10], [2, 3], [4, 5], [6, 7]], [[1, 10]], id="all_merged"),
+    ],
+)
 def test_merge_intervals(intervals, expected):
     assert merge_intervals(intervals) == expected
 
-@pytest.mark.parametrize("nums, expected", [
-    pytest.param([2, 2, 1], 1, id="simple_case"),
-    pytest.param([4, 1, 2, 1, 2], 4, id="middle_single"),
-    pytest.param([1], 1, id="single_element"),
-    pytest.param([100, 200, 300, 200, 100], 300, id="large_numbers"),
-    pytest.param([0, 1, 0], 1, id="with_zero"),
-    pytest.param([7, 8, 9, 8, 7], 9, id="unsorted"),
-    pytest.param([i + 10**5 for i in range(500)] + [i + 10**5 for i in range(500)] + [69], 69, id="long_list"),
-])
+
+@pytest.mark.parametrize(
+    "nums, expected",
+    [
+        pytest.param([2, 2, 1], 1, id="simple_case"),
+        pytest.param([4, 1, 2, 1, 2], 4, id="middle_single"),
+        pytest.param([1], 1, id="single_element"),
+        pytest.param([100, 200, 300, 200, 100], 300, id="large_numbers"),
+        pytest.param([0, 1, 0], 1, id="with_zero"),
+        pytest.param([7, 8, 9, 8, 7], 9, id="unsorted"),
+        pytest.param(
+            [i + 10**5 for i in range(500)] + [i + 10**5 for i in range(500)] + [69],
+            69,
+            id="long_list",
+        ),
+    ],
+)
 def test_find_single_number(nums, expected):
     assert find_single_number(nums) == expected
 
-@pytest.mark.parametrize("input_list, expected_list, expected_index", [
-    pytest.param([0, 1, 0, 3, 12], [1, 3, 12, 0, 0], 3, id="basic"),
-    pytest.param([0, 0, 1], [1, 0, 0], 1, id="zeros_first"),
-    pytest.param([1, 2, 3], [1, 2, 3], 3, id="no_zeros"),
-    pytest.param([0, 0, 0], [0, 0, 0], 0, id="all_zeros"),
-    pytest.param([1, 0, 2, 0, 3, 0], [1, 2, 3, 0, 0, 0], 3, id="interleaved"),
-    pytest.param([], [], 0, id="empty"),
-    pytest.param([0], [0], 0, id="single_zero"),
-    pytest.param([42], [42], 1, id="single_nonzero"),
-])
+
+@pytest.mark.parametrize(
+    "input_list, expected_list, expected_index",
+    [
+        pytest.param([0, 1, 0, 3, 12], [1, 3, 12, 0, 0], 3, id="basic"),
+        pytest.param([0, 0, 1], [1, 0, 0], 1, id="zeros_first"),
+        pytest.param([1, 2, 3], [1, 2, 3], 3, id="no_zeros"),
+        pytest.param([0, 0, 0], [0, 0, 0], 0, id="all_zeros"),
+        pytest.param([1, 0, 2, 0, 3, 0], [1, 2, 3, 0, 0, 0], 3, id="interleaved"),
+        pytest.param([], [], 0, id="empty"),
+        pytest.param([0], [0], 0, id="single_zero"),
+        pytest.param([42], [42], 1, id="single_nonzero"),
+    ],
+)
 def test_move_zeros_to_end_parametrized(input_list, expected_list, expected_index):
     arr = input_list[:]
     result_index = move_zeros_to_end(arr)
@@ -71,89 +99,54 @@ def test_move_zeros_to_end_parametrized(input_list, expected_list, expected_inde
     assert result_index == expected_index
 
 
-@pytest.mark.parametrize("matrix, expected_row", [
-    pytest.param(
-        [[0, 0, 1, 1],
-         [0, 1, 1, 1],
-         [0, 0, 0, 1],
-         [1, 1, 1, 1],
-         [0, 1, 1, 1]],
-        3,
-        id="classic"
-    ),
-    pytest.param(
-        [[0, 0, 0],
-         [0, 0, 0],
-         [0, 0, 0]],
-        0,
-        id="all_zeros"
-    ),
-    pytest.param(
-        [[1, 1, 1],
-         [1, 1, 1],
-         [1, 1, 1]],
-        0,
-        id="all_ones_first"
-    ),
-    pytest.param(
-        [[0, 1],
-         [1, 1]],
-        1,
-        id="two_rows"
-    ),
-    pytest.param(
-        [[0]],
-        0,
-        id="single_zero"
-    ),
-    pytest.param(
-        [[1]],
-        0,
-        id="single_one"
-    ),
-    pytest.param(
-        [],
-        0,
-        id="empty_matrix"
-    ),
-    pytest.param(
-        [[0, 0, 1],
-         [0, 1, 1],
-         [0, 1, 1]], 
-        1, 
-        id="tie"
-    ),
-])
+@pytest.mark.parametrize(
+    "matrix, expected_row",
+    [
+        pytest.param(
+            [[0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 0, 1], [1, 1, 1, 1], [0, 1, 1, 1]], 3, id="classic"
+        ),
+        pytest.param([[0, 0, 0], [0, 0, 0], [0, 0, 0]], 0, id="all_zeros"),
+        pytest.param([[1, 1, 1], [1, 1, 1], [1, 1, 1]], 0, id="all_ones_first"),
+        pytest.param([[0, 1], [1, 1]], 1, id="two_rows"),
+        pytest.param([[0]], 0, id="single_zero"),
+        pytest.param([[1]], 0, id="single_one"),
+        pytest.param([], 0, id="empty_matrix"),
+        pytest.param([[0, 0, 1], [0, 1, 1], [0, 1, 1]], 1, id="tie"),
+    ],
+)
 def test_find_row_with_most_ones(matrix, expected_row):
     assert find_row_with_most_ones(matrix) == expected_row
 
 
 def test_find_row_with_most_ones_big_data():
     size = 10000
-    matrix = [[0]*size for i in range(size)]
-    matrix[size-1][size-1] = 1
+    matrix = [[0] * size for i in range(size)]
+    matrix[size - 1][size - 1] = 1
 
     for i in range(50):
         assert find_row_with_most_ones(matrix) == 9999
 
     size = 10000
-    matrix = [[1]*size for i in range(size)]
+    matrix = [[1] * size for i in range(size)]
     matrix[0][0] = 0
 
     for i in range(50):
         assert find_row_with_most_ones(matrix) == 1
 
 
-@pytest.mark.parametrize("input_arr, expected", [
-    pytest.param([0], 1, id="self_loop"),
-    pytest.param([1, 0], 1, id="two_cycle"),
-    pytest.param([1, 2, 0], 1, id="three_cycle"),
-    pytest.param([0, 1, 2], 3, id="three_self_loops"),
-    pytest.param([1, 0, 3, 2], 2, id="two_2_cycles"),
-    pytest.param([2, 0, 1, 4, 3], 2, id="mixed_cycles"),
-    pytest.param([10, 6, 2, 9, 4, 0, 3, 8, 7, 1, 5], 5, id="mixed_cycles"),
-    pytest.param([], 0, id="empty"),
-])
+@pytest.mark.parametrize(
+    "input_arr, expected",
+    [
+        pytest.param([0], 1, id="self_loop"),
+        pytest.param([1, 0], 1, id="two_cycle"),
+        pytest.param([1, 2, 0], 1, id="three_cycle"),
+        pytest.param([0, 1, 2], 3, id="three_self_loops"),
+        pytest.param([1, 0, 3, 2], 2, id="two_2_cycles"),
+        pytest.param([2, 0, 1, 4, 3], 2, id="mixed_cycles"),
+        pytest.param([10, 6, 2, 9, 4, 0, 3, 8, 7, 1, 5], 5, id="mixed_cycles"),
+        pytest.param([], 0, id="empty"),
+    ],
+)
 def test_count_cycles(input_arr, expected):
     arr = input_arr[:]
     assert count_cycles(arr) == expected
diff --git a/deprecated_tests/sem01/tests/test_lesson05_tasks.py b/deprecated_tests/sem01/tests/test_lesson05_tasks.py
index 72ad6bc8..a43a2a45 100644
--- a/deprecated_tests/sem01/tests/test_lesson05_tasks.py
+++ b/deprecated_tests/sem01/tests/test_lesson05_tasks.py
@@ -1,4 +1,4 @@
-import pytest 
+import pytest
 
 from solutions.sem01.lesson05.task1 import is_palindrome
 from solutions.sem01.lesson05.task2 import are_anagrams
@@ -7,145 +7,166 @@
 from solutions.sem01.lesson05.task5 import reg_validator
 from solutions.sem01.lesson05.task6 import simplify_path
 
-@pytest.mark.parametrize("s, expected", [
-    pytest.param("", True, id="empty_string"),
-    pytest.param("a", True, id="single_char"),
-    pytest.param("aa", True, id="two_same"),
-    pytest.param("ab", False, id="two_different"),
-    pytest.param("aba", True, id="odd_palindrome"),
-    pytest.param("abba", True, id="even_palindrome"),
-    pytest.param("abcba", True, id="long_odd_palindrome"),
-    pytest.param("abccba", True, id="long_even_palindrome"),
-    pytest.param("abc", False, id="not_palindrome"),
-    pytest.param("Aa", True, id="case_sensitive_mismatch"),
-    pytest.param("Racecar", True, id="real_word_case_sensitive"),
-    pytest.param("aA", True, id="reverse_case"),
-    pytest.param("abcdefedcba", True, id="long_true"),
-    pytest.param("abcdefedcbx", False, id="long_false"),
-])
+
+@pytest.mark.parametrize(
+    "s, expected",
+    [
+        pytest.param("", True, id="empty_string"),
+        pytest.param("a", True, id="single_char"),
+        pytest.param("aa", True, id="two_same"),
+        pytest.param("ab", False, id="two_different"),
+        pytest.param("aba", True, id="odd_palindrome"),
+        pytest.param("abba", True, id="even_palindrome"),
+        pytest.param("abcba", True, id="long_odd_palindrome"),
+        pytest.param("abccba", True, id="long_even_palindrome"),
+        pytest.param("abc", False, id="not_palindrome"),
+        pytest.param("Aa", True, id="case_sensitive_mismatch"),
+        pytest.param("Racecar", True, id="real_word_case_sensitive"),
+        pytest.param("aA", True, id="reverse_case"),
+        pytest.param("abcdefedcba", True, id="long_true"),
+        pytest.param("abcdefedcbx", False, id="long_false"),
+    ],
+)
 def test_is_palindrome(s, expected):
     assert is_palindrome(s) == expected
 
 
-@pytest.mark.parametrize("w1, w2, expected", [
-    pytest.param("listen", "silent", True, id="classic_anagram"),
-    pytest.param("evil", "vile", True, id="another_anagram"),
-    pytest.param("a", "a", True, id="single_char_same"),
-    pytest.param("A", "A", True, id="single_upper_same"),
-    pytest.param("A", "a", False, id="case_sensitive_diff"),
-    pytest.param("Listen", "Silent", False, id="mixed_case_not_anagram"),
-    pytest.param("Aa", "aA", True, id="same_chars_permuted"),
-    pytest.param("Ab", "ab", False, id="one_letter_case_diff"),
-    pytest.param("abc", "cba", True, id="permuted_same_case"),
-    pytest.param("abc", "Cba", False, id="case_breaks_anagram"),
-    pytest.param("aabbcc", "abcabc", True, id="repeated_letters"),
-    pytest.param("aabbcc", "aabbcd", False, id="extra_different_char"),
-])
+@pytest.mark.parametrize(
+    "w1, w2, expected",
+    [
+        pytest.param("listen", "silent", True, id="classic_anagram"),
+        pytest.param("evil", "vile", True, id="another_anagram"),
+        pytest.param("a", "a", True, id="single_char_same"),
+        pytest.param("A", "A", True, id="single_upper_same"),
+        pytest.param("A", "a", False, id="case_sensitive_diff"),
+        pytest.param("Listen", "Silent", False, id="mixed_case_not_anagram"),
+        pytest.param("Aa", "aA", True, id="same_chars_permuted"),
+        pytest.param("Ab", "ab", False, id="one_letter_case_diff"),
+        pytest.param("abc", "cba", True, id="permuted_same_case"),
+        pytest.param("abc", "Cba", False, id="case_breaks_anagram"),
+        pytest.param("aabbcc", "abcabc", True, id="repeated_letters"),
+        pytest.param("aabbcc", "aabbcd", False, id="extra_different_char"),
+    ],
+)
 def test_are_anagrams_linear(w1, w2, expected):
     assert are_anagrams(w1, w2) == expected
 
 
-@pytest.mark.parametrize("s, expected", [
-    pytest.param("!!!", True, id="only_exclamations"),
-    pytest.param("...?", True, id="dots_and_question"),
-    pytest.param("", False, id="empty_string"),
-    pytest.param("a", False, id="letter"),
-    pytest.param("1", False, id="digit"),
-    pytest.param(" ! ", False, id="space_inside"),
-    pytest.param("!?.", True, id="symbols_only"),
-    pytest.param("!a!", False, id="letter_in_middle"),
-    pytest.param(" ", False, id="only_space"),
-    pytest.param(".,;", True, id="commas_dots_semicolons"),
-    pytest.param("", False, id="commas_dots_semicolons"),
-])
+@pytest.mark.parametrize(
+    "s, expected",
+    [
+        pytest.param("!!!", True, id="only_exclamations"),
+        pytest.param("...?", True, id="dots_and_question"),
+        pytest.param("", False, id="empty_string"),
+        pytest.param("a", False, id="letter"),
+        pytest.param("1", False, id="digit"),
+        pytest.param(" ! ", False, id="space_inside"),
+        pytest.param("!?.", True, id="symbols_only"),
+        pytest.param("!a!", False, id="letter_in_middle"),
+        pytest.param(" ", False, id="only_space"),
+        pytest.param(".,;", True, id="commas_dots_semicolons"),
+        pytest.param("", False, id="commas_dots_semicolons"),
+    ],
+)
 def test_is_only_punctuation(s, expected):
     assert is_punctuation(s) == expected
 
-@pytest.mark.parametrize("compressed, expected", [
-    pytest.param("AbcD*4 ef GhI*2", "AbcDAbcDAbcDAbcDefGhIGhI", id="example"),
-    pytest.param("a*3 b*2", "aaabb", id="simple_letters"),
-    pytest.param("Hello", "Hello", id="star_one"),
-    pytest.param("xyz", "xyz", id="no_compression"),
-    pytest.param("", "", id="empty_input"),
-    pytest.param("Test*2 Space", "TestTestSpace", id="mixed"),
-    pytest.param("a*10", "aaaaaaaaaa", id="ten_a"),
-    pytest.param("x y z", "xyz", id="three_plain"),
-    pytest.param("Word word", "Wordword", id="case_sensitive"),
-])
+
+@pytest.mark.parametrize(
+    "compressed, expected",
+    [
+        pytest.param("AbcD*4 ef GhI*2", "AbcDAbcDAbcDAbcDefGhIGhI", id="example"),
+        pytest.param("a*3 b*2", "aaabb", id="simple_letters"),
+        pytest.param("Hello", "Hello", id="star_one"),
+        pytest.param("xyz", "xyz", id="no_compression"),
+        pytest.param("", "", id="empty_input"),
+        pytest.param("Test*2 Space", "TestTestSpace", id="mixed"),
+        pytest.param("a*10", "aaaaaaaaaa", id="ten_a"),
+        pytest.param("x y z", "xyz", id="three_plain"),
+        pytest.param("Word word", "Wordword", id="case_sensitive"),
+    ],
+)
 def test_decompress(compressed, expected):
     assert unzip(compressed) == expected
 
-@pytest.mark.parametrize("regexp, s, expected", [
-    pytest.param("d", "123", True, id="d_valid_number"),
-    pytest.param("d", "0", True, id="d_zero"),
-    pytest.param("d", "abc", False, id="d_letters_instead_of_digits"),
-    pytest.param("d", "", False, id="d_empty_string"),
-    pytest.param("w", "hello", True, id="w_lowercase_word"),
-    pytest.param("w", "HelloWorld", True, id="w_mixed_case_word"),
-    pytest.param("w", "hello123", False, id="w_word_with_digits"),
-    pytest.param("w", "", False, id="w_empty_string"),
-    pytest.param("s", "abc123", True, id="s_alphanum"),
-    pytest.param("s", "ABC99", True, id="s_uppercase_and_digits"),
-    pytest.param("s", "abc_123", False, id="s_contains_underscore"),
-    pytest.param("s", "", False, id="s_empty_string"),
-    pytest.param("d-d", "12-34", True, id="d_dash_d_valid"),
-    pytest.param("d-d", "12--34", False, id="d_dash_d_double_dash"),
-    pytest.param("d-d", "12-abc", False, id="d_dash_d_letters_after_dash"),
-    pytest.param("d-d", "1234", False, id="d_dash_d_missing_dash"),
-    pytest.param("w.w", "hi.there", True, id="w_dot_w_valid"),
-    pytest.param("w.w", "hi..there", False, id="w_dot_w_double_dot"),
-    pytest.param("w.w", "hi1.there", False, id="w_dot_w_digit_in_first_word"),
-    pytest.param("s.s", "h1i.th32ere", True, id="s_dot_s_valid"),
-    pytest.param("s.s", "hi4..t2here", False, id="s_dot_s_double_dot"),
-    pytest.param("d-dw", "12-45abc", True, id="example_valid"),
-    pytest.param("d-dw", "1-abs", False, id="example_second_part_not_digit"),
-    pytest.param("d-dw", "1-b123r", False, id="example_letter_after_dash"),
-    pytest.param("d-dw", "1--123vdg", False, id="example_double_dash"),
-    pytest.param("d-dw", "123-456XYZ", True, id="d-dw_all_caps"),
-    pytest.param("d-dw", "0-0a", True, id="d-dw_minimal_valid"),
-    pytest.param("d@d", "5@7", True, id="d_at_d_valid"),
-    pytest.param("d@d", "5@@7", False, id="d_at_d_double_at"),
-    pytest.param("w s", "hi 123", True, id="w_space_s_valid"),
-    pytest.param("w s", "hi123", False, id="w_space_s_missing_space"),
-    pytest.param("w s", "hi 123!", False, id="w_space_s_extra_char_in_s"),
-    pytest.param("", "", True, id="empty_regexp_empty_string"),
-    pytest.param("", "a", False, id="empty_regexp_non_empty_string"),
-    pytest.param("d", "", False, id="non_empty_regexp_empty_string"),
-    pytest.param("d!", "5!", True, id="d_exclam_valid"),
-    pytest.param("d!", "5", False, id="d_exclam_missing_exclam"),
-    pytest.param("d!", "5!!", False, id="d_exclam_extra_exclam"),
-    pytest.param("s", "a1", True, id="s_letter_digit"),
-    pytest.param("s", "1a", True, id="s_digit_letter"),
-    pytest.param("s", "a!1", False, id="s_contains_exclamation"),
-    pytest.param("d-w-s", "123-abc-XY1Z23", True, id="d_w_s_valid"),
-    pytest.param("d-w-s", "123-abc-XYZ_123", False, id="d_w_s_underscore_in_s"),
-])
+
+@pytest.mark.parametrize(
+    "regexp, s, expected",
+    [
+        pytest.param("d", "123", True, id="d_valid_number"),
+        pytest.param("d", "0", True, id="d_zero"),
+        pytest.param("d", "abc", False, id="d_letters_instead_of_digits"),
+        pytest.param("d", "", False, id="d_empty_string"),
+        pytest.param("w", "hello", True, id="w_lowercase_word"),
+        pytest.param("w", "HelloWorld", True, id="w_mixed_case_word"),
+        pytest.param("w", "hello123", False, id="w_word_with_digits"),
+        pytest.param("w", "", False, id="w_empty_string"),
+        pytest.param("s", "abc123", True, id="s_alphanum"),
+        pytest.param("s", "ABC99", True, id="s_uppercase_and_digits"),
+        pytest.param("s", "abc_123", False, id="s_contains_underscore"),
+        pytest.param("s", "", False, id="s_empty_string"),
+        pytest.param("d-d", "12-34", True, id="d_dash_d_valid"),
+        pytest.param("d-d", "12--34", False, id="d_dash_d_double_dash"),
+        pytest.param("d-d", "12-abc", False, id="d_dash_d_letters_after_dash"),
+        pytest.param("d-d", "1234", False, id="d_dash_d_missing_dash"),
+        pytest.param("w.w", "hi.there", True, id="w_dot_w_valid"),
+        pytest.param("w.w", "hi..there", False, id="w_dot_w_double_dot"),
+        pytest.param("w.w", "hi1.there", False, id="w_dot_w_digit_in_first_word"),
+        pytest.param("s.s", "h1i.th32ere", True, id="s_dot_s_valid"),
+        pytest.param("s.s", "hi4..t2here", False, id="s_dot_s_double_dot"),
+        pytest.param("d-dw", "12-45abc", True, id="example_valid"),
+        pytest.param("d-dw", "1-abs", False, id="example_second_part_not_digit"),
+        pytest.param("d-dw", "1-b123r", False, id="example_letter_after_dash"),
+        pytest.param("d-dw", "1--123vdg", False, id="example_double_dash"),
+        pytest.param("d-dw", "123-456XYZ", True, id="d-dw_all_caps"),
+        pytest.param("d-dw", "0-0a", True, id="d-dw_minimal_valid"),
+        pytest.param("d@d", "5@7", True, id="d_at_d_valid"),
+        pytest.param("d@d", "5@@7", False, id="d_at_d_double_at"),
+        pytest.param("w s", "hi 123", True, id="w_space_s_valid"),
+        pytest.param("w s", "hi123", False, id="w_space_s_missing_space"),
+        pytest.param("w s", "hi 123!", False, id="w_space_s_extra_char_in_s"),
+        pytest.param("", "", True, id="empty_regexp_empty_string"),
+        pytest.param("", "a", False, id="empty_regexp_non_empty_string"),
+        pytest.param("d", "", False, id="non_empty_regexp_empty_string"),
+        pytest.param("d!", "5!", True, id="d_exclam_valid"),
+        pytest.param("d!", "5", False, id="d_exclam_missing_exclam"),
+        pytest.param("d!", "5!!", False, id="d_exclam_extra_exclam"),
+        pytest.param("s", "a1", True, id="s_letter_digit"),
+        pytest.param("s", "1a", True, id="s_digit_letter"),
+        pytest.param("s", "a!1", False, id="s_contains_exclamation"),
+        pytest.param("d-w-s", "123-abc-XY1Z23", True, id="d_w_s_valid"),
+        pytest.param("d-w-s", "123-abc-XYZ_123", False, id="d_w_s_underscore_in_s"),
+    ],
+)
 def test_match_pattern(regexp, s, expected):
     assert reg_validator(regexp, s) == expected
 
 
-@pytest.mark.parametrize("path, expected", [
-    pytest.param("/home/", "/home", id="trailing_slash"),
-    pytest.param("/../", "", id="go_above_root"),
-    pytest.param("/home//foo/", "/home/foo", id="double_slash"),
-    pytest.param("/home/./foo/", "/home/foo", id="current_dir_dot"),
-    pytest.param("/./././", "/", id="only_dots_and_slashes"),
-    pytest.param("/a/./b/../../c/", "/c", id="complex_up_and_down"),
-    pytest.param("/a/b/c/../../../", "/", id="back_to_root"),
-    pytest.param("/", "/", id="root_only"),
-    pytest.param("/.", "/", id="root_with_dot"),
-    pytest.param("/..", "", id="root_with_double_dot"),
-    pytest.param("/...", "/...", id="triple_dot_as_name"),
-    pytest.param("/..a", "/..a", id="dot_dot_a_as_name"),
-    pytest.param("/a.b/c.d", "/a.b/c.d", id="names_with_dots"),
-    pytest.param("/a//b////c/d//././/..", "/a/b/c", id="messy_path"),
-    pytest.param("/a/./b/./c/./d", "/a/b/c/d", id="dots_everywhere"),
-    pytest.param("/a/./b/../../c/./d/", "/c/d", id="up_down_with_dots"),
-    pytest.param("/../foo", "", id="up_then_valid"),
-    pytest.param("/../../foo", "", id="multiple_up_then_valid"),
-    pytest.param("/../../../", "", id="three_up_from_root"),
-    pytest.param("/home/foo/./../../../", "", id="too_many_up"),
-    pytest.param("/_a.b/c__1/..", "/_a.b", id="names_with_underscores_and_dots"),
-])
+@pytest.mark.parametrize(
+    "path, expected",
+    [
+        pytest.param("/home/", "/home", id="trailing_slash"),
+        pytest.param("/../", "", id="go_above_root"),
+        pytest.param("/home//foo/", "/home/foo", id="double_slash"),
+        pytest.param("/home/./foo/", "/home/foo", id="current_dir_dot"),
+        pytest.param("/./././", "/", id="only_dots_and_slashes"),
+        pytest.param("/a/./b/../../c/", "/c", id="complex_up_and_down"),
+        pytest.param("/a/b/c/../../../", "/", id="back_to_root"),
+        pytest.param("/", "/", id="root_only"),
+        pytest.param("/.", "/", id="root_with_dot"),
+        pytest.param("/..", "", id="root_with_double_dot"),
+        pytest.param("/...", "/...", id="triple_dot_as_name"),
+        pytest.param("/..a", "/..a", id="dot_dot_a_as_name"),
+        pytest.param("/a.b/c.d", "/a.b/c.d", id="names_with_dots"),
+        pytest.param("/a//b////c/d//././/..", "/a/b/c", id="messy_path"),
+        pytest.param("/a/./b/./c/./d", "/a/b/c/d", id="dots_everywhere"),
+        pytest.param("/a/./b/../../c/./d/", "/c/d", id="up_down_with_dots"),
+        pytest.param("/../foo", "", id="up_then_valid"),
+        pytest.param("/../../foo", "", id="multiple_up_then_valid"),
+        pytest.param("/../../../", "", id="three_up_from_root"),
+        pytest.param("/home/foo/./../../../", "", id="too_many_up"),
+        pytest.param("/_a.b/c__1/..", "/_a.b", id="names_with_underscores_and_dots"),
+    ],
+)
 def test_simplify_path(path, expected):
-    assert simplify_path(path) == expected
\ No newline at end of file
+    assert simplify_path(path) == expected
diff --git a/deprecated_tests/sem01/tests/test_lesson06_tasks.py b/deprecated_tests/sem01/tests/test_lesson06_tasks.py
index 707d6609..f2f6a282 100644
--- a/deprecated_tests/sem01/tests/test_lesson06_tasks.py
+++ b/deprecated_tests/sem01/tests/test_lesson06_tasks.py
@@ -1,4 +1,4 @@
-import pytest 
+import pytest
 
 from solutions.sem01.lesson06.task1 import int_to_roman
 from solutions.sem01.lesson06.task2 import get_len_of_longest_substring
@@ -6,103 +6,122 @@
 from solutions.sem01.lesson06.task4 import count_unique_words
 
 
-@pytest.mark.parametrize("num, expected", [
-    pytest.param(1, "I", id="one"),
-    pytest.param(2, "II", id="two"),
-    pytest.param(3, "III", id="three"),
-    pytest.param(4, "IV", id="four"),
-    pytest.param(5, "V", id="five"),
-    pytest.param(6, "VI", id="six"),
-    pytest.param(9, "IX", id="nine"),
-    pytest.param(10, "X", id="ten"),
-    pytest.param(11, "XI", id="eleven"),
-    pytest.param(14, "XIV", id="fourteen"),
-    pytest.param(19, "XIX", id="nineteen"),
-    pytest.param(27, "XXVII", id="twenty_seven"),
-    pytest.param(40, "XL", id="forty"),
-    pytest.param(44, "XLIV", id="forty_four"),
-    pytest.param(50, "L", id="fifty"),
-    pytest.param(58, "LVIII", id="fifty_eight"),
-    pytest.param(90, "XC", id="ninety"),
-    pytest.param(99, "XCIX", id="ninety_nine"),
-    pytest.param(100, "C", id="hundred"),
-    pytest.param(400, "CD", id="four_hundred"),
-    pytest.param(500, "D", id="five_hundred"),
-    pytest.param(900, "CM", id="nine_hundred"),
-    pytest.param(1000, "M", id="thousand"),
-    pytest.param(1994, "MCMXCIV", id="mcmxciv"),
-    pytest.param(3999, "MMMCMXCIX", id="max_value"),
-    pytest.param(2023, "MMXXIII", id="current_year"),
-    pytest.param(1984, "MCMLXXXIV", id="classic"),
-])
+@pytest.mark.parametrize(
+    "num, expected",
+    [
+        pytest.param(1, "I", id="one"),
+        pytest.param(2, "II", id="two"),
+        pytest.param(3, "III", id="three"),
+        pytest.param(4, "IV", id="four"),
+        pytest.param(5, "V", id="five"),
+        pytest.param(6, "VI", id="six"),
+        pytest.param(9, "IX", id="nine"),
+        pytest.param(10, "X", id="ten"),
+        pytest.param(11, "XI", id="eleven"),
+        pytest.param(14, "XIV", id="fourteen"),
+        pytest.param(19, "XIX", id="nineteen"),
+        pytest.param(27, "XXVII", id="twenty_seven"),
+        pytest.param(40, "XL", id="forty"),
+        pytest.param(44, "XLIV", id="forty_four"),
+        pytest.param(50, "L", id="fifty"),
+        pytest.param(58, "LVIII", id="fifty_eight"),
+        pytest.param(90, "XC", id="ninety"),
+        pytest.param(99, "XCIX", id="ninety_nine"),
+        pytest.param(100, "C", id="hundred"),
+        pytest.param(400, "CD", id="four_hundred"),
+        pytest.param(500, "D", id="five_hundred"),
+        pytest.param(900, "CM", id="nine_hundred"),
+        pytest.param(1000, "M", id="thousand"),
+        pytest.param(1994, "MCMXCIV", id="mcmxciv"),
+        pytest.param(3999, "MMMCMXCIX", id="max_value"),
+        pytest.param(2023, "MMXXIII", id="current_year"),
+        pytest.param(1984, "MCMLXXXIV", id="classic"),
+    ],
+)
 def test_int_to_roman(num, expected):
     assert int_to_roman(num) == expected
 
-@pytest.mark.parametrize("s, expected", [
-    pytest.param("", 0, id="empty_string"),
-    pytest.param("a", 1, id="single_char"),
-    pytest.param("aa", 1, id="two_same_chars"),
-    pytest.param("ab", 2, id="two_different_chars"),
-    pytest.param("abcabcbb", 3, id="classic_example_abc"),
-    pytest.param("bbbbb", 1, id="all_same"),
-    pytest.param("pwwkew", 3, id="pwwkew_example"),
-    pytest.param("abcdef", 6, id="all_unique"),
-    pytest.param("abcabcbbxyz", 4, id="long_tail_unique"),
-    pytest.param("aab", 2, id="aab"),
-    pytest.param("dvdf", 3, id="dvdf"),
-    pytest.param(" ", 1, id="single_space"),
-    pytest.param("a b c", 3, id="letters_and_spaces_unique"),
-    pytest.param("a b a", 3, id="space_in_middle_with_repeat"),
-    pytest.param("1234567890", 10, id="digits_all_unique"),
-    pytest.param("112233", 2, id="repeating_digits"),
-    pytest.param("abcdefghijklmnopqrstuvwxyz", 26, id="all_lowercase_letters"),
-    pytest.param("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ", 63, id="max_unique_set"),
-    pytest.param("a" * 10000, 1, id="ten_thousand_same"),
-    pytest.param("abc" * 3333 + "d", 4, id="long_repeating_with_new_char"),
-])
+
+@pytest.mark.parametrize(
+    "s, expected",
+    [
+        pytest.param("", 0, id="empty_string"),
+        pytest.param("a", 1, id="single_char"),
+        pytest.param("aa", 1, id="two_same_chars"),
+        pytest.param("ab", 2, id="two_different_chars"),
+        pytest.param("abcabcbb", 3, id="classic_example_abc"),
+        pytest.param("bbbbb", 1, id="all_same"),
+        pytest.param("pwwkew", 3, id="pwwkew_example"),
+        pytest.param("abcdef", 6, id="all_unique"),
+        pytest.param("abcabcbbxyz", 4, id="long_tail_unique"),
+        pytest.param("aab", 2, id="aab"),
+        pytest.param("dvdf", 3, id="dvdf"),
+        pytest.param(" ", 1, id="single_space"),
+        pytest.param("a b c", 3, id="letters_and_spaces_unique"),
+        pytest.param("a b a", 3, id="space_in_middle_with_repeat"),
+        pytest.param("1234567890", 10, id="digits_all_unique"),
+        pytest.param("112233", 2, id="repeating_digits"),
+        pytest.param("abcdefghijklmnopqrstuvwxyz", 26, id="all_lowercase_letters"),
+        pytest.param(
+            "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ",
+            63,
+            id="max_unique_set",
+        ),
+        pytest.param("a" * 10000, 1, id="ten_thousand_same"),
+        pytest.param("abc" * 3333 + "d", 4, id="long_repeating_with_new_char"),
+    ],
+)
 def test_get_len_of_longest_substring(s, expected):
     assert get_len_of_longest_substring(s) == expected
 
-@pytest.mark.parametrize("nums, k, expected", [
-    pytest.param([23, 2, 4, 6, 7], 6, True, id="subarray_2_4_sum_6"),
-    pytest.param([23, 2, 6, 4, 7], 6, True, id="total_sum_42_div_by_6"),
-    pytest.param([23, 2, 6, 4, 7], 13, False, id="no_valid_subarray"),
-    pytest.param([0, 0], 1, True, id="two_zeros_any_k"),
-    pytest.param([1, 0], 2, False, id="length_2_sum_1_not_div_by_2"),
-    pytest.param([1, 2, 3], 5, True, id="subarray_2_3_sum_5"),
-    pytest.param([1], 1, False, id="single_element_too_short"),
-    pytest.param([5, 0, 0], 3, True, id="zeros_after_nonzero"),
-    pytest.param([1, 2], 3, True, id="exact_sum_equals_k"),
-    pytest.param([1, 2], 4, False, id="sum_not_divisible_by_k"),
-    pytest.param([0], 1, False, id="single_zero_too_short"),
-    pytest.param([1, 0, 2], 2, True, id="subarray_0_2_sum_2"),
-    pytest.param([4, 2, 4], 6, True, id="first_two_sum_6"),
-    pytest.param([1, 1, 1], 2, True, id="first_two_ones_sum_2"),
-    pytest.param([1, 2, 4, 8], 8, False, id="no_subarray_divisible_by_8"),
-    pytest.param([0, 1, 0], 2, False, id="zeros_with_one_sum_1"),
-    pytest.param([0, 1, 0, 0], 2, True, id="last_two_zeros_sum_0_div_by_any"),
-])
+
+@pytest.mark.parametrize(
+    "nums, k, expected",
+    [
+        pytest.param([23, 2, 4, 6, 7], 6, True, id="subarray_2_4_sum_6"),
+        pytest.param([23, 2, 6, 4, 7], 6, True, id="total_sum_42_div_by_6"),
+        pytest.param([23, 2, 6, 4, 7], 13, False, id="no_valid_subarray"),
+        pytest.param([0, 0], 1, True, id="two_zeros_any_k"),
+        pytest.param([1, 0], 2, False, id="length_2_sum_1_not_div_by_2"),
+        pytest.param([1, 2, 3], 5, True, id="subarray_2_3_sum_5"),
+        pytest.param([1], 1, False, id="single_element_too_short"),
+        pytest.param([5, 0, 0], 3, True, id="zeros_after_nonzero"),
+        pytest.param([1, 2], 3, True, id="exact_sum_equals_k"),
+        pytest.param([1, 2], 4, False, id="sum_not_divisible_by_k"),
+        pytest.param([0], 1, False, id="single_zero_too_short"),
+        pytest.param([1, 0, 2], 2, True, id="subarray_0_2_sum_2"),
+        pytest.param([4, 2, 4], 6, True, id="first_two_sum_6"),
+        pytest.param([1, 1, 1], 2, True, id="first_two_ones_sum_2"),
+        pytest.param([1, 2, 4, 8], 8, False, id="no_subarray_divisible_by_8"),
+        pytest.param([0, 1, 0], 2, False, id="zeros_with_one_sum_1"),
+        pytest.param([0, 1, 0, 0], 2, True, id="last_two_zeros_sum_0_div_by_any"),
+    ],
+)
 def test_is_there_any_good_subarray(nums, k, expected):
     assert is_there_any_good_subarray(nums, k) == expected
 
 
 import pytest
 
-@pytest.mark.parametrize("text, expected", [
-    pytest.param("", 0, id="empty_string"),
-    pytest.param("   ", 0, id="only_spaces"),
-    pytest.param("hello", 1, id="single_word"),
-    pytest.param("Hello hello", 1, id="case_insensitive"),
-    pytest.param("Hello, world!", 2, id="punctuation_around"),
-    pytest.param("Hello, hello, world!", 2, id="duplicates_with_punct"),
-    pytest.param("The quick brown fox jumps over the lazy dog.", 8, id="classic_pangram"),
-    pytest.param("!!! ???", 0, id="only_punctuation"),
-    pytest.param("word1 word2 word1", 2, id="digits_in_words"),
-    pytest.param("Don't stop believing!", 3, id="apostrophe_inside"),
-    pytest.param("   Hello ,   World !   ", 2, id="extra_whitespace"),
-    pytest.param("A a A a", 1, id="repeated_case_variants"),
-    pytest.param("word... word!!!", 1, id="multiple_punct_at_end"),
-    pytest.param("123 456 123", 2, id="numbers_as_words"),
-])
+
+@pytest.mark.parametrize(
+    "text, expected",
+    [
+        pytest.param("", 0, id="empty_string"),
+        pytest.param("   ", 0, id="only_spaces"),
+        pytest.param("hello", 1, id="single_word"),
+        pytest.param("Hello hello", 1, id="case_insensitive"),
+        pytest.param("Hello, world!", 2, id="punctuation_around"),
+        pytest.param("Hello, hello, world!", 2, id="duplicates_with_punct"),
+        pytest.param("The quick brown fox jumps over the lazy dog.", 8, id="classic_pangram"),
+        pytest.param("!!! ???", 0, id="only_punctuation"),
+        pytest.param("word1 word2 word1", 2, id="digits_in_words"),
+        pytest.param("Don't stop believing!", 3, id="apostrophe_inside"),
+        pytest.param("   Hello ,   World !   ", 2, id="extra_whitespace"),
+        pytest.param("A a A a", 1, id="repeated_case_variants"),
+        pytest.param("word... word!!!", 1, id="multiple_punct_at_end"),
+        pytest.param("123 456 123", 2, id="numbers_as_words"),
+    ],
+)
 def test_count_unique_words(text, expected):
-    assert count_unique_words(text) == expected
\ No newline at end of file
+    assert count_unique_words(text) == expected
diff --git a/deprecated_tests/sem01/tests/test_lesson08_tasks.py b/deprecated_tests/sem01/tests/test_lesson08_tasks.py
index 962ba4bd..06f04319 100644
--- a/deprecated_tests/sem01/tests/test_lesson08_tasks.py
+++ b/deprecated_tests/sem01/tests/test_lesson08_tasks.py
@@ -1,10 +1,10 @@
-import pytest 
 import math
 import time
 
 from solutions.sem01.lesson08.task1 import make_averager
 from solutions.sem01.lesson08.task2 import collect_statistic
 
+
 def test_make_averager():
     get_avg = make_averager(2)
 
@@ -15,6 +15,7 @@ def test_make_averager():
     assert math.isclose(get_avg(5), 1)
     assert math.isclose(get_avg(5), 5)
 
+
 def test_make_averager2():
     get_avg = make_averager(5)
 
@@ -27,6 +28,7 @@ def test_make_averager2():
     assert math.isclose(get_avg(-7), 0)
     assert math.isclose(get_avg(-2), -1)
 
+
 def test_collect_statistic():
     statistics: list[str, list[float, int]] = {}
 
@@ -37,7 +39,7 @@ def func1() -> None:
     @collect_statistic(statistics)
     def func2() -> None:
         time.sleep(0.1)
-    
+
     for _ in range(3):
         func1()
 
@@ -58,10 +60,11 @@ def test_collect_statistic_inout():
     @collect_statistic(statistics)
     def func(a, b, *, c, d):
         return a + b + c + d
-    
+
     assert func(1, 2, c=3, d=4) == 10
     assert statistics[func.__name__][1] == 1
 
+
 def test_collect_statistic_count_call():
     statistics: list[str, list[float, int]] = {}
 
@@ -76,7 +79,7 @@ def func():
             count_call += 1
 
         return func
-    
+
     func = func_fab()
     func()
-    assert statistics[func.__name__][1] == 1
\ No newline at end of file
+    assert statistics[func.__name__][1] == 1
diff --git a/deprecated_tests/sem01/tests/test_lesson11_tasks.py b/deprecated_tests/sem01/tests/test_lesson11_tasks.py
index d0cd02ef..941eed77 100644
--- a/deprecated_tests/sem01/tests/test_lesson11_tasks.py
+++ b/deprecated_tests/sem01/tests/test_lesson11_tasks.py
@@ -1,9 +1,8 @@
-import pytest
-
 import math
 import sys
 from io import StringIO
 
+import pytest
 
 from solutions.sem01.lesson11.task1 import Vector2D
 
@@ -84,13 +83,12 @@ def test_print():
     sys.stdout = old_stdout
     output = captured_output.getvalue()
     assert (
-        output == "Vector2D(abscissa=1, ordinate=-2)" 
+        output == "Vector2D(abscissa=1, ordinate=-2)"
         or output == "Vector2D(abscissa=1., ordinate=-2.)"
-        or output == "Vector2D(abscissa=1.0, ordinate=-2.0)" 
+        or output == "Vector2D(abscissa=1.0, ordinate=-2.0)"
     )
 
 
-
 @pytest.mark.parametrize(
     "abscissa1, ordinate1, abscissa2, ordinate2, expected",
     [
diff --git a/deprecated_tests/sem01/tests_hw/test_hw1_tasks.py b/deprecated_tests/sem01/tests_hw/test_hw1_tasks.py
index 0ecf8a10..c600f76d 100644
--- a/deprecated_tests/sem01/tests_hw/test_hw1_tasks.py
+++ b/deprecated_tests/sem01/tests_hw/test_hw1_tasks.py
@@ -1,17 +1,15 @@
-import pytest
 import uuid
-from unittest.mock import MagicMock, patch, Mock
+from unittest.mock import MagicMock, Mock, patch
+
+import pytest
 
-from homeworks.sem01.hw1.aggregate_segmentation import aggregate_segmentation, ALLOWED_TYPES
+from homeworks.sem01.hw1.aggregate_segmentation import ALLOWED_TYPES, aggregate_segmentation
 from homeworks.sem01.hw1.backoff import backoff
 from homeworks.sem01.hw1.cache import lru_cache
 from homeworks.sem01.hw1.convert_exception import convert_exceptions_to_api_compitable_ones
-from .hw1_test_data.cache_test_data import (
-    TESTCASE_DATA,
-    TESTCASE_IDS,
-)
 
-NAME_BACKOFF_MODULE = "homeworks.hw1.backoff" # название модуля с backoff
+NAME_BACKOFF_MODULE = "homeworks.hw1.backoff"  # название модуля с backoff
+
 
 def test_valid_segments() -> None:
     """Тест: валидные сегменты."""
@@ -32,53 +30,53 @@ def test_valid_segments() -> None:
             "segment_id": segment_id_1,
             "segment_start": 0.0,
             "segment_end": 1.0,
-            "type": list_allow_types[0]
+            "type": list_allow_types[0],
         },
         {
             "audio_id": audio_id_1,
             "segment_id": segment_id_2,
             "segment_start": 2.5,
             "segment_end": 3.5,
-            "type": list_allow_types[1]
+            "type": list_allow_types[1],
         },
         {
             "audio_id": audio_id_2,
             "segment_id": segment_id_3,
             "segment_start": 4.5,
             "segment_end": 4.6,
-            "type": list_allow_types[0]
+            "type": list_allow_types[0],
         },
         {
             "audio_id": audio_id_2,
             "segment_id": segment_id_4,
             "segment_start": 5.5,
             "segment_end": 6.5,
-            "type": list_allow_types[1]
+            "type": list_allow_types[1],
         },
         {
             "audio_id": audio_id_3,
             "segment_id": segment_id_5,
             "segment_start": None,
             "segment_end": None,
-            "type": None
+            "type": None,
         },
         {
             "audio_id": "audio3",
             "segment_id": "seg5",
             "segment_start": 0.0,
             "segment_end": 1.0,
-            "type": "invalid_type"
+            "type": "invalid_type",
         },
     ]
 
     expected_valid = {
         audio_id_1: {
             segment_id_1: {"start": 0.0, "end": 1.0, "type": list_allow_types[0]},
-            segment_id_2: {"start": 2.5, "end": 3.5, "type": list_allow_types[1]}
+            segment_id_2: {"start": 2.5, "end": 3.5, "type": list_allow_types[1]},
         },
         audio_id_2: {
             segment_id_3: {"start": 4.5, "end": 4.6, "type": list_allow_types[0]},
-            segment_id_4: {"start": 5.5, "end": 6.5, "type": list_allow_types[1]}
+            segment_id_4: {"start": 5.5, "end": 6.5, "type": list_allow_types[1]},
         },
         audio_id_3: {},
     }
@@ -88,6 +86,7 @@ def test_valid_segments() -> None:
     assert result_valid == expected_valid
     assert result_forbidden == expected_forbidden
 
+
 def test_convert_matching_exception() -> None:
     """Тест: исключение заменяется на API-совместимое."""
 
@@ -97,7 +96,7 @@ class ApiValueError(Exception):
     @convert_exceptions_to_api_compitable_ones({ValueError: ApiValueError})
     def func():
         raise ValueError("Внутренняя ошибка")
-    
+
     @convert_exceptions_to_api_compitable_ones({ValueError: ApiValueError})
     def func2():
         raise KeyError("Внутренняя ошибка")
@@ -108,7 +107,8 @@ def func2():
     with pytest.raises(KeyError):
         func2()
 
-@patch(NAME_BACKOFF_MODULE + '.sleep')
+
+@patch(NAME_BACKOFF_MODULE + ".sleep")
 def test_exponential_backoff_and_jitter(mock_sleep: MagicMock) -> None:
     """Тест: задержки увеличиваются, но не выше timeout_max и к ним добавляется дрожь."""
     attempts = 0
@@ -116,12 +116,7 @@ def test_exponential_backoff_and_jitter(mock_sleep: MagicMock) -> None:
     retry_amount = 4
     timeouts = [1, 2, 4, 4]
 
-    @backoff(
-        retry_amount=retry_amount,
-        timeout_start=1,
-        timeout_max=timeout_max,
-        backoff_scale=2.0
-    )
+    @backoff(retry_amount=retry_amount, timeout_start=1, timeout_max=timeout_max, backoff_scale=2.0)
     def func():
         nonlocal attempts
         attempts += 1
@@ -138,22 +133,23 @@ def func():
     for av_time, args in zip(timeouts, args_list):
         count_more_av_time += args > av_time
         assert av_time <= args <= av_time + 0.5
-    
-    assert count_more_av_time   # есть добавление "дрожи"
+
+    assert count_more_av_time  # есть добавление "дрожи"
+
 
 def test_success() -> None:
     capacity = 2
-    call_args =  [
+    call_args = [
         (1, 2),
         (1, 2),
         (2, 2),
     ]
     call_count_expected = 2
-    
+
     mock_func = Mock()
     func_cached = lru_cache(capacity=capacity)(mock_func)
 
     for args in call_args:
         func_cached(args)
 
-    assert mock_func.call_count == call_count_expected
\ No newline at end of file
+    assert mock_func.call_count == call_count_expected
diff --git a/deprecated_tests/sem02/tests/task4/test_lesson04_tasks.py b/deprecated_tests/sem02/tests/task4/test_lesson04_tasks.py
index 37d249b7..81312dea 100644
--- a/deprecated_tests/sem02/tests/task4/test_lesson04_tasks.py
+++ b/deprecated_tests/sem02/tests/task4/test_lesson04_tasks.py
@@ -333,12 +333,8 @@ class TestTask2:
             ),
         ],
     )
-    def test_get_dominant_color_info(
-        self, image, threshold, expected_color, expected_ratio
-    ):
-        color, ratio_percent = get_dominant_color_info(
-            image.astype(np.uint8), threshold
-        )
+    def test_get_dominant_color_info(self, image, threshold, expected_color, expected_ratio):
+        color, ratio_percent = get_dominant_color_info(image.astype(np.uint8), threshold)
 
         assert color in expected_color
         assert (abs(ratio_percent - expected_ratio * 100) < 1e-6) or (
diff --git a/deprecated_tests/sem02/tests/task5/test_lesson05_tasks.py b/deprecated_tests/sem02/tests/task5/test_lesson05_tasks.py
index aeb37ebc..4cc9188d 100644
--- a/deprecated_tests/sem02/tests/task5/test_lesson05_tasks.py
+++ b/deprecated_tests/sem02/tests/task5/test_lesson05_tasks.py
@@ -89,9 +89,7 @@ class TestTask1:
             ),
         ],
     )
-    def test_can_satisfy_demand(
-        self, costs, resource_amounts, demand_expected, expected
-    ):
+    def test_can_satisfy_demand(self, costs, resource_amounts, demand_expected, expected):
         assert can_satisfy_demand(costs, resource_amounts, demand_expected) == expected
 
     def test_can_satisfy_demand_validate(self):
@@ -172,9 +170,7 @@ class TestTask2:
             ),
         ],
     )
-    def test_get_projections_components(
-        self, matrix, vector, proj_expected, orth_expected
-    ):
+    def test_get_projections_components(self, matrix, vector, proj_expected, orth_expected):
         projections, orthogonals = get_projections_components(matrix, vector)
 
         if proj_expected is None:
diff --git a/homeworks/sem01/hw1/backoff.py b/homeworks/sem01/hw1/backoff.py
index 696ffa73..a3373a98 100644
--- a/homeworks/sem01/hw1/backoff.py
+++ b/homeworks/sem01/hw1/backoff.py
@@ -1,5 +1,3 @@
-from random import uniform
-from time import sleep
 from typing import (
     Callable,
     ParamSpec,
diff --git a/solutions/sem01/lesson03/task1.py b/solutions/sem01/lesson03/task1.py
index f1d8fe26..7b048e65 100644
--- a/solutions/sem01/lesson03/task1.py
+++ b/solutions/sem01/lesson03/task1.py
@@ -1,3 +1,3 @@
 def flip_bits_in_range(num: int, left_bit: int, right_bit: int) -> int:
     # ваш код
-    return num
\ No newline at end of file
+    return num
diff --git a/solutions/sem01/lesson03/task2.py b/solutions/sem01/lesson03/task2.py
index a3a738c2..5cf2b631 100644
--- a/solutions/sem01/lesson03/task2.py
+++ b/solutions/sem01/lesson03/task2.py
@@ -1,3 +1,3 @@
 def get_cube_root(n: float, eps: float) -> float:
     # ваш код
-    return n
\ No newline at end of file
+    return n
diff --git a/solutions/sem01/lesson04/task1.py b/solutions/sem01/lesson04/task1.py
index 47384423..0135e399 100644
--- a/solutions/sem01/lesson04/task1.py
+++ b/solutions/sem01/lesson04/task1.py
@@ -1,3 +1,3 @@
 def is_arithmetic_progression(lst: list[list[int]]) -> bool:
     # ваш код
-    return False
\ No newline at end of file
+    return False
diff --git a/solutions/sem01/lesson04/task2.py b/solutions/sem01/lesson04/task2.py
index 4591d0a3..5d6f8ee8 100644
--- a/solutions/sem01/lesson04/task2.py
+++ b/solutions/sem01/lesson04/task2.py
@@ -1,3 +1,3 @@
 def merge_intervals(intervals: list[list[int, int]]) -> list[list[int, int]]:
     # ваш код
-    return [[0,0]]
\ No newline at end of file
+    return [[0, 0]]
diff --git a/solutions/sem01/lesson04/task4.py b/solutions/sem01/lesson04/task4.py
index b21bc5a3..2664384d 100644
--- a/solutions/sem01/lesson04/task4.py
+++ b/solutions/sem01/lesson04/task4.py
@@ -1,3 +1,3 @@
 def move_zeros_to_end(nums: list[int]) -> list[int]:
     # ваш код
-    return 0
\ No newline at end of file
+    return 0
diff --git a/solutions/sem01/lesson04/task5.py b/solutions/sem01/lesson04/task5.py
index 02d7742b..ec6932ee 100644
--- a/solutions/sem01/lesson04/task5.py
+++ b/solutions/sem01/lesson04/task5.py
@@ -1,3 +1,3 @@
 def find_row_with_most_ones(matrix: list[list[int]]) -> int:
     # ваш код
-    return 0
\ No newline at end of file
+    return 0
diff --git a/solutions/sem01/lesson04/task6.py b/solutions/sem01/lesson04/task6.py
index 16df27ca..d16e77dd 100644
--- a/solutions/sem01/lesson04/task6.py
+++ b/solutions/sem01/lesson04/task6.py
@@ -1,3 +1,3 @@
-def count_cycles(arr: list[int]) -> int: 
+def count_cycles(arr: list[int]) -> int:
     # ваш код
-    return 0
\ No newline at end of file
+    return 0
diff --git a/solutions/sem01/lesson05/task1.py b/solutions/sem01/lesson05/task1.py
index 9a17211e..fdf3b548 100644
--- a/solutions/sem01/lesson05/task1.py
+++ b/solutions/sem01/lesson05/task1.py
@@ -1,3 +1,3 @@
 def is_palindrome(text: str) -> bool:
     # ваш код
-    return False
\ No newline at end of file
+    return False
diff --git a/solutions/sem01/lesson05/task2.py b/solutions/sem01/lesson05/task2.py
index 36750380..c70b4029 100644
--- a/solutions/sem01/lesson05/task2.py
+++ b/solutions/sem01/lesson05/task2.py
@@ -1,3 +1,3 @@
 def are_anagrams(word1: str, word2: str) -> bool:
     # ваш код
-    return False
\ No newline at end of file
+    return False
diff --git a/solutions/sem01/lesson05/task4.py b/solutions/sem01/lesson05/task4.py
index 4c4e9086..7c2c26f1 100644
--- a/solutions/sem01/lesson05/task4.py
+++ b/solutions/sem01/lesson05/task4.py
@@ -1,3 +1,3 @@
 def unzip(compress_text: str) -> str:
     # ваш код
-    return compress_text
\ No newline at end of file
+    return compress_text
diff --git a/solutions/sem01/lesson05/task5.py b/solutions/sem01/lesson05/task5.py
index 076c5bb6..da9e6d08 100644
--- a/solutions/sem01/lesson05/task5.py
+++ b/solutions/sem01/lesson05/task5.py
@@ -1,3 +1,3 @@
-def reg_validator(reg_expr: str, text: str) -> bool:  
+def reg_validator(reg_expr: str, text: str) -> bool:
     # ваш код
-    return False
\ No newline at end of file
+    return False
diff --git a/solutions/sem01/lesson05/task6.py b/solutions/sem01/lesson05/task6.py
index 1b914ada..63207797 100644
--- a/solutions/sem01/lesson05/task6.py
+++ b/solutions/sem01/lesson05/task6.py
@@ -1,3 +1,3 @@
 def simplify_path(path: str) -> str:
     # ваш код
-    return path
\ No newline at end of file
+    return path
diff --git a/solutions/sem01/lesson06/task1.py b/solutions/sem01/lesson06/task1.py
index 2d1e30e9..353cb361 100644
--- a/solutions/sem01/lesson06/task1.py
+++ b/solutions/sem01/lesson06/task1.py
@@ -1,3 +1,3 @@
 def int_to_roman(num: int) -> str:
     # ваш код
-    return ""
\ No newline at end of file
+    return ""
diff --git a/solutions/sem01/lesson06/task2.py b/solutions/sem01/lesson06/task2.py
index f535b5a0..f1034e24 100644
--- a/solutions/sem01/lesson06/task2.py
+++ b/solutions/sem01/lesson06/task2.py
@@ -1,3 +1,3 @@
 def get_len_of_longest_substring(text: str) -> int:
     # ваш код
-    return 0
\ No newline at end of file
+    return 0
diff --git a/solutions/sem01/lesson06/task3.py b/solutions/sem01/lesson06/task3.py
index 7449a1e7..b160d615 100644
--- a/solutions/sem01/lesson06/task3.py
+++ b/solutions/sem01/lesson06/task3.py
@@ -2,6 +2,5 @@ def is_there_any_good_subarray(
     nums: list[int],
     k: int,
 ) -> bool:
-    
     # ваш код
     return False
diff --git a/solutions/sem01/lesson06/task4.py b/solutions/sem01/lesson06/task4.py
index 5b75a110..95a7098e 100644
--- a/solutions/sem01/lesson06/task4.py
+++ b/solutions/sem01/lesson06/task4.py
@@ -1,3 +1,3 @@
 def count_unique_words(text: str) -> int:
     # ваш код
-    return 0
\ No newline at end of file
+    return 0
diff --git a/solutions/sem01/lesson08/task1.py b/solutions/sem01/lesson08/task1.py
index 4390f6c8..7fa724ef 100644
--- a/solutions/sem01/lesson08/task1.py
+++ b/solutions/sem01/lesson08/task1.py
@@ -1,5 +1,6 @@
 from typing import Callable
 
+
 def make_averager(accumulation_period: int) -> Callable[[float], float]:
     # ваш код
-    pass
\ No newline at end of file
+    pass
diff --git a/solutions/sem01/lesson08/task2.py b/solutions/sem01/lesson08/task2.py
index 6e4af870..cc2ae430 100644
--- a/solutions/sem01/lesson08/task2.py
+++ b/solutions/sem01/lesson08/task2.py
@@ -2,9 +2,7 @@
 
 T = TypeVar("T")
 
-def collect_statistic(
-    statistics: dict[str, list[float, int]]
-) -> Callable[[T], T]:
-    
+
+def collect_statistic(statistics: dict[str, list[float, int]]) -> Callable[[T], T]:
     # ваш код
-    pass
\ No newline at end of file
+    pass
diff --git a/solutions/sem01/lesson12/task3.py b/solutions/sem01/lesson12/task3.py
index 64c112cc..58b0986e 100644
--- a/solutions/sem01/lesson12/task3.py
+++ b/solutions/sem01/lesson12/task3.py
@@ -1,6 +1,3 @@
-import sys
-
-
 class FileOut:
     def __init__(
         self,
diff --git a/solutions/sem02/lesson07/task1.py b/solutions/sem02/lesson07/task1.py
index 3a505d89..5e1e4b37 100644
--- a/solutions/sem02/lesson07/task1.py
+++ b/solutions/sem02/lesson07/task1.py
@@ -13,8 +13,58 @@ def visualize_diagrams(
     ordinates: np.ndarray,
     diagram_type: Any,
 ) -> None:
-    # ваш код
-    pass
+    if abscissa.shape != ordinates.shape:
+        raise ShapeMismatchError
+    if diagram_type not in {"box", "violin", "hist"}:
+        raise ValueError
+    grid = plt.GridSpec(4, 4, wspace=0.2, hspace=0.2)
+    figure = plt.figure(figsize=(8, 8))
+    scatter = figure.add_subplot(grid[:-1, 1:])
+    abs = figure.add_subplot(grid[:-1, 0], sharex=scatter)
+    ord = figure.add_subplot(grid[-1, 1:], sharey=scatter)
+    scatter.scatter(abscissa, ordinates, color="green", alpha=0.5)
+    if diagram_type == "box":
+        ord.boxplot(
+            ordinates,
+            patch_artist=True,
+            boxprops=dict(facecolor="red", color="lightgreen"),
+            medianprops=dict(color="black"),
+        )
+        abs.boxplot(
+            abscissa,
+            vert=False,
+            patch_artist=True,
+            boxprops=dict(facecolor="red", color="lightgreen"),
+            medianprops=dict(color="black"),
+        )
+        abs.invert_yaxis()
+        ord.invert_xaxis()
+    elif diagram_type == "hist":
+        ord.hist(abscissa, bins=100, color="lightgreen", density=True, alpha=0.5)
+        abs.hist(
+            ordinates,
+            orientation="horizontal",
+            bins=100,
+            color="lightgreen",
+            density=True,
+            alpha=0.5,
+        )
+        ord.invert_xaxis()
+        abs.invert_yaxis()
+    else:
+        vert = ord.violinplot(ordinates, showmedians=True)
+        hor = abs.violinplot(abscissa, showmedians=True, vert=False)
+        for v in [hor, vert]:
+            for body in v["bodies"]:
+                body.set_facecolor("lightgreen")
+                body.set_edgecolor("green")
+                body.set_alpha(0.5)
+            for i in v:
+                if i == "bodies":
+                    continue
+                v[i].set_edgecolor("lightgreen")
+        abs.invert_yaxis()
+        ord.invert_xaxis()
 
 
 if __name__ == "__main__":
diff --git a/solutions/sem02/lesson07/task2.py b/solutions/sem02/lesson07/task2.py
index decd607e..106bd03b 100644
--- a/solutions/sem02/lesson07/task2.py
+++ b/solutions/sem02/lesson07/task2.py
@@ -1 +1,26 @@
 # ваш код (используйте функции или классы для решения данной задачи)
+import json
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+def solve():
+    plt.style.use("ggplot")
+    info = json.load(open("data/medic_data.json", "r", encoding="utf-8"))
+    bef = np.array(info["before"])
+    aft = np.array(info["after"])
+    levels = ["I", "II", "III", "IV"]
+    befc = np.array([np.sum(bef == lev) for lev in levels])
+    aftc = np.array([np.sum(aft == lev) for lev in levels])
+    f, ax = plt.subplots(figsize=(16, 10))
+    x = np.arange(len(levels))
+    ax.bar(x - 0.5 / 2, befc, 0.5, label="Before", color="green", edgecolor="black")
+    ax.bar(x + 0.5 / 2, aftc, 0.5, label="After", color="blue", edgecolor="black")
+    ax.set_title("Mitral disease stages", fontsize=15, fontweight="bold", color="black")
+    ax.set_ylabel("Amount of people", fontsize=15, fontweight="bold", color="black")
+    ax.set_xticks(x)
+    ax.set_xticklabels(levels, fontweight="bold")
+    ax.legend()
+    plt.show()
+if __name__ == "__main__":
+    solve()
\ No newline at end of file