[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

tutorial/pandas_helpers.py

@@ -14,6 +14,7 @@ def low_med_high_bins_viz(data, column, ylabel, title, figsize=(15, 3)):
         ["low", "med", "high"],
         ["///", "", "\\\\\\"],
         pd.cut(data[column], bins=3).unique().categories.values,
+        strict=False,
     ):
         plt.axhspan(
             bounds.left,
@@ -45,6 +46,7 @@ def quartile_bins_viz(data, column, ylabel, title, figsize=(15, 8)):
         [r"$Q_1$", r"$Q_2$", r"$Q_3$", r"$Q_4$"],
         ["\\\\\\", "", "///", "||||"],
         pd.qcut(data.volume, q=4).unique().categories.values,
+        strict=False,
     ):
         plt.axhspan(
             bounds.left,

tutorial/tests/test_01_basic_datatypes.py

@@ -1,6 +1,7 @@
 import copy
 import math
-from typing import Any, Callable, Hashable, Iterable
+from collections.abc import Callable, Hashable, Iterable
+from typing import Any
 
 import pytest
 
@@ -364,7 +365,7 @@ def reference_dict_return_value(my_dict: dict[Hashable, Any], key: Any) -> Any:
 
 
 @pytest.mark.parametrize(
-    "my_dict, key", list(zip(copy.deepcopy(DICTS1), ["b"] * len(DICTS1)))
+    "my_dict, key", list(zip(copy.deepcopy(DICTS1), ["b"] * len(DICTS1), strict=False))
 )
 def test_dict_return_value(my_dict, key, function_to_test):
     my_dict_to_try = my_dict.copy()
@@ -380,7 +381,7 @@ def reference_dict_return_delete_value(my_dict: dict[Hashable, Any], key: Any) -
 
 
 @pytest.mark.parametrize(
-    "my_dict, key", list(zip(copy.deepcopy(DICTS1), ["b"] * len(DICTS1)))
+    "my_dict, key", list(zip(copy.deepcopy(DICTS1), ["b"] * len(DICTS1), strict=False))
 )
 def test_dict_return_delete_value(my_dict, key, function_to_test):
     my_dict_original1 = my_dict.copy()
@@ -400,7 +401,8 @@ def reference_update_one_dict_with_another(
 
 
 @pytest.mark.parametrize(
-    "my_dict1, my_dict2", list(zip(copy.deepcopy(DICTS1), copy.deepcopy(DICTS2)))
+    "my_dict1, my_dict2",
+    list(zip(copy.deepcopy(DICTS1), copy.deepcopy(DICTS2), strict=False)),
 )
 def test_update_one_dict_with_another(my_dict1, my_dict2, function_to_test):
     my_dict1_original1 = my_dict1.copy()

tutorial/tests/test_02_control_flow.py

@@ -1,7 +1,7 @@
 import contextlib
 import pathlib
 from math import isclose, sqrt
-from typing import Any, List, Optional, Tuple
+from typing import Any
 
 import pytest
 
@@ -16,7 +16,7 @@ def read_data(name: str, data_dir: str = "data") -> pathlib.Path:
 #
 
 
-def reference_indexed_string(string: str) -> List[Tuple[str, int]]:
+def reference_indexed_string(string: str) -> list[tuple[str, int]]:
     """Reference solution warm-up 1"""
     result = []
     for i, char in enumerate(string):
@@ -45,7 +45,7 @@ def test_indexed_string(string: str, function_to_test) -> None:
     assert reference_indexed_string(string) == result
 
 
-def reference_range_of_nums(start: int, end: int) -> List[int]:
+def reference_range_of_nums(start: int, end: int) -> list[int]:
     """Reference solution warm-up 2"""
     step = 1 if start < end else -1
     return list(range(start, end + step, step))
@@ -67,7 +67,7 @@ def test_range_of_nums(start: int, end: int, function_to_test) -> None:
     )
 
 
-def reference_sqrt_of_nums(numbers: List[int]) -> List[float]:
+def reference_sqrt_of_nums(numbers: list[int]) -> list[float]:
     """Reference solution warm-up 3"""
     result = []
     for num in numbers:
@@ -104,7 +104,7 @@ def test_sqrt_of_nums(nums: list[int], function_to_test) -> None:
     assert len(reference) == len(result), (
         "The function should return a list of the same length"
     )
-    assert all(isclose(x, y) for x, y in zip(reference, result)), (
+    assert all(isclose(x, y) for x, y in zip(reference, result, strict=False)), (
         "The function should return the square root of each number"
     )
 
@@ -128,7 +128,7 @@ def test_divide_until(num: int, function_to_test) -> None:
 #
 
 
-def reference_filter_by_position(numbers: List[int]) -> List[int]:
+def reference_filter_by_position(numbers: list[int]) -> list[int]:
     result = set()
     for pos, number in enumerate(numbers, start=1):
         if number > pos:
@@ -149,7 +149,7 @@ def reference_filter_by_position(numbers: List[int]) -> List[int]:
         [10, 20, 1, 2, 3],  # Mixed large and small numbers = {10, 20}
     ],
 )
-def test_filter_by_position(numbers: List[int], function_to_test) -> None:
+def test_filter_by_position(numbers: list[int], function_to_test) -> None:
     """Test filtering numbers by position."""
     assert function_to_test(numbers) == reference_filter_by_position(numbers)
 
@@ -159,7 +159,7 @@ def test_filter_by_position(numbers: List[int], function_to_test) -> None:
 #
 
 
-def reference_find_even_multiple_three(numbers: List[int]) -> Optional[int]:
+def reference_find_even_multiple_three(numbers: list[int]) -> int | None:
     result = None
     for number in numbers:
         if number % 2 == 0 and number % 3 == 0:
@@ -179,7 +179,7 @@ def reference_find_even_multiple_three(numbers: List[int]) -> Optional[int]:
         [1, 3, 5, 7, 12],  # Valid number at the end = 12
     ],
 )
-def test_find_even_multiple_three(numbers: List[int], function_to_test) -> None:
+def test_find_even_multiple_three(numbers: list[int], function_to_test) -> None:
     """Test finding first even multiple of 3."""
     assert function_to_test(numbers) == reference_find_even_multiple_three(numbers)
 
@@ -233,7 +233,7 @@ def test_is_pure_number(text: str, function_to_test) -> None:
 #
 
 
-def reference_find_factors(num: int) -> List[int]:
+def reference_find_factors(num: int) -> list[int]:
     """Reference solution to find the factors of an integer"""
     factors = []
     for m in range(1, num + 1):
@@ -257,21 +257,21 @@ def test_find_factors(num: int, function_to_test) -> None:
 )
 
 
-def reference_find_pair(nums: List[int]):
+def reference_find_pair(nums: list[int]):
     """
     Reference solutions:
         - A solution with two nested loops
         - A solution using a dictionary and a single loop
     """
 
-    def find_pair_with_double_loop(nums: List[int]) -> Optional[int]:
+    def find_pair_with_double_loop(nums: list[int]) -> int | None:
         """Two nested loops"""
         for i in nums:
             for j in nums:
                 if i + j == 2020:
                     return i * j
 
-    def find_pair_with_sets(nums: List[int]) -> Optional[int]:
+    def find_pair_with_sets(nums: list[int]) -> int | None:
         """Using a dictionary and a single loop"""
         complements = {}
         for num in nums:
@@ -280,7 +280,7 @@ def find_pair_with_sets(nums: List[int]) -> Optional[int]:
             complements[2020 - num] = num
 
 
-def __reference_find_pair(nums: List[int]) -> Optional[int]:
+def __reference_find_pair(nums: list[int]) -> int | None:
     """Reference solution (part 1)"""
     complements = {}
     for num in nums:
@@ -290,18 +290,18 @@ def __reference_find_pair(nums: List[int]) -> Optional[int]:
 
 
 @pytest.mark.parametrize("nums", [nums_1, nums_2])
-def test_find_pair(nums: List[int], function_to_test) -> None:
+def test_find_pair(nums: list[int], function_to_test) -> None:
     assert function_to_test(nums) == __reference_find_pair(nums)
 
 
-def reference_find_triplet(nums: List[int]):
+def reference_find_triplet(nums: list[int]):
     """
     Reference solutions:
         - A slow solution with three nested loops
         - A fast solution using only two loops
     """
 
-    def find_triplet_slow(nums: List[int]) -> Optional[int]:
+    def find_triplet_slow(nums: list[int]) -> int | None:
         """Slow solution with a triple loop"""
         n = len(nums)
         for i in range(n - 2):
@@ -310,7 +310,7 @@ def find_triplet_slow(nums: List[int]) -> Optional[int]:
                     if nums[i] + nums[j] + nums[k] == 2020:
                         return nums[i] * nums[j] * nums[k]
 
-    def find_triplet_best(nums: List[int]) -> Optional[int]:
+    def find_triplet_best(nums: list[int]) -> int | None:
         """Fast solution with two loops"""
         n = len(nums)
         for i in range(n - 1):
@@ -323,7 +323,7 @@ def find_triplet_best(nums: List[int]) -> Optional[int]:
                 s.add(nums[j])
 
 
-def __reference_find_triplet(nums: List[int]) -> Optional[int]:
+def __reference_find_triplet(nums: list[int]) -> int | None:
     """Reference solution (part 2), O(n^2)"""
     n = len(nums)
     for i in range(n - 1):
@@ -337,7 +337,7 @@ def __reference_find_triplet(nums: List[int]) -> Optional[int]:
 
 
 @pytest.mark.parametrize("nums", [nums_1, nums_2])
-def test_find_triplet(nums: List[int], function_to_test) -> None:
+def test_find_triplet(nums: list[int], function_to_test) -> None:
     assert function_to_test(nums) == __reference_find_triplet(nums)
 
 

tutorial/tests/test_03_functions.py

@@ -2,7 +2,7 @@
 import pathlib
 from collections import Counter
 from string import ascii_lowercase, ascii_uppercase
-from typing import Any, List
+from typing import Any
 
 import pytest
 
@@ -270,7 +270,7 @@ def test_combine_anything(args: Any, function_to_test) -> None:
 #
 
 
-def reference_longest_sequence(nums: List[int]) -> int:
+def reference_longest_sequence(nums: list[int]) -> int:
     """
     Find the longest consecutive sequence of integers
 
@@ -301,7 +301,7 @@ def reference_longest_sequence(nums: List[int]) -> int:
         [0, 2, 14, 12, 4, 18, 16, 8, 10, 6],
     ],
 )
-def test_longest_sequence(input_nums: List[int], function_to_test) -> None:
+def test_longest_sequence(input_nums: list[int], function_to_test) -> None:
     assert function_to_test(input_nums) == reference_longest_sequence(input_nums)
 
 
@@ -312,7 +312,7 @@ def test_longest_sequence(input_nums: List[int], function_to_test) -> None:
         [int(x) for x in read_data("longest_10000.txt").read_text().splitlines()],
     ],
 )
-def test_longest_sequence_best(input_nums: List[int], function_to_test) -> None:
+def test_longest_sequence_best(input_nums: list[int], function_to_test) -> None:
     assert function_to_test(input_nums) == reference_longest_sequence(input_nums)
 
 

tutorial/tests/test_04_input_output.py

@@ -3,7 +3,6 @@
 import pathlib as pl
 import string
 from io import StringIO
-from typing import Dict, List, Tuple
 
 import pytest
 
@@ -34,7 +33,7 @@ def test_print_odd(function_to_test, n: int):
     assert solution_text == reference_text
 
 
-def reference_check_for_file(current_path: pl.Path, file_name: str) -> List[pl.Path]:
+def reference_check_for_file(current_path: pl.Path, file_name: str) -> list[pl.Path]:
     for file_path in list(current_path.iterdir()):
         if file_name == file_path.name:
             return True
@@ -54,7 +53,7 @@ def test_check_for_file(function_to_test, input_path: pl.Path, file_name: str):
     )
 
 
-def reference_find_all_files(current_path: pl.Path) -> List[pl.Path]:
+def reference_find_all_files(current_path: pl.Path) -> list[pl.Path]:
     return list(current_path.iterdir())
 
 
@@ -72,7 +71,7 @@ def test_count_dirs(function_to_test):
     assert function_to_test(path) == reference_count_dirs(path)
 
 
-def reference_read_file(input_file: pl.Path) -> List[str]:
+def reference_read_file(input_file: pl.Path) -> list[str]:
     text = input_file.open("r")
     lines = text.readlines()
     text.close()
@@ -148,7 +147,7 @@ def test_read_write_file(function_to_test, tmp_path: pl.Path):
         input_file.write_text(original_content)
 
 
-def reference_exercise1(input_file: pl.Path) -> Dict[str, List[str]]:
+def reference_exercise1(input_file: pl.Path) -> dict[str, list[str]]:
     my_dict = {}
     with open(input_file) as csv_file:
         reader = csv.reader(csv_file)
@@ -191,7 +190,7 @@ def test_exercise2(function_to_test, file: str):
         f.write_text(original_content)
 
 
-def reference_exercise3(input_file: pl.Path) -> Dict[str, int]:
+def reference_exercise3(input_file: pl.Path) -> dict[str, int]:
     my_dict = {}
     my_dict = dict.fromkeys(string.ascii_lowercase, 0)
     with open(input_file) as file_ob:
@@ -217,7 +216,7 @@ def test_exercise3(function_to_test):
         f.write_text(original_content)
 
 
-def reference_exercise4(english: pl.Path, dictionary: pl.Path) -> List[Tuple[str, str]]:
+def reference_exercise4(english: pl.Path, dictionary: pl.Path) -> list[tuple[str, str]]:
     english_words = english.read_text().splitlines()
 
     with dictionary.open("r") as dict_file: