Flask exercises

filter_map/filter_map.py

@@ -15,4 +15,10 @@ def filter_map(func: Callable[[Any], Tuple[bool, Any]], input_array: List[Any])
         :param input_array: Исходный список.
         :return: Отфильтрованный список.
         """
-        pass
+
+        filtered_list = []
+        for items in input_array:
+            result = func(items)
+            if result[0]:
+                filtered_list.append(result[1])
+        return filtered_list

flask_exercises/flask_excercises.py

@@ -1,4 +1,10 @@
-from flask import Flask
+from typing import Any, Tuple
+
+from flask import Flask, jsonify, request
+
+app = Flask(__name__)
+
+flask_dict = {}
 
 
 class FlaskExercise:
@@ -28,4 +34,41 @@ class FlaskExercise:
 
     @staticmethod
     def configure_routes(app: Flask) -> None:
-        pass
+        app.add_url_rule("/user", view_func=FlaskExercise.create, methods=["POST"])
+        app.add_url_rule("/user/<username>", view_func=FlaskExercise.retrieve, methods=["GET"])
+        app.add_url_rule("/user/<username>", view_func=FlaskExercise.update, methods=["PATCH"])
+        app.add_url_rule("/user/<username>", view_func=FlaskExercise.delete, methods=["DELETE"])
+
+    @staticmethod
+    def create() -> tuple:
+        data = request.json.get("name")
+        if data:
+            flask_dict[data] = dict()
+            return {"data": f"User {data} is created!"}, 201
+        return jsonify({"errors": {"name": "This field is required"}}), 422
+
+    @staticmethod
+    def retrieve(username: str) -> tuple:
+        if username in flask_dict:
+            return jsonify({"data": f"My name is {username}"}), 200
+        return jsonify({"errors": "User not found"}), 404
+
+    @staticmethod
+    def update(username: str) -> tuple:
+        data = request.json.get("name")
+        if username in flask_dict:
+            flask_dict[data] = flask_dict[username]
+            del flask_dict[username]
+            return {"data": f"My name is {data}"}, 200
+        return jsonify({"errors": {"name": "Имя не найдено"}}), 404
+
+    @staticmethod
+    def delete(username: str) -> Tuple[Any, int]:
+        if username in flask_dict:
+            del flask_dict[username]
+            return "", 204
+        return {"errors": {"name": "Имя не найдено"}}, 404
+
+
+if __name__ == "__main__":
+    app.run(debug=True)

flask_exercises/test_flask_excercises.py

@@ -3,7 +3,6 @@
 
 from flask import Flask
 from flask.testing import FlaskClient
-import pytest
 
 from .flask_excercises import FlaskExercise
 
@@ -43,13 +42,11 @@ def delete_user(self, username: str) -> dict:
         assert response.status_code == HTTPStatus.NO_CONTENT
         return response.get_json()
 
-    @pytest.mark.skip
     def test_create(self) -> None:
         response = self.create_user({"name": "Heisenberg"})
 
         assert response == {"data": "User Heisenberg is created!"}
 
-    @pytest.mark.skip
     def test_unprocessable_entity(self) -> None:
         response = self.flask_client.post(
             "/user",
@@ -58,31 +55,28 @@ def test_unprocessable_entity(self) -> None:
         )
 
         assert response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY
-        assert response == {"errors": {"name": "This field is required"}}
+        assert response.get_json() == {
+            "errors": {"name": "This field is required"}}
 
-    @pytest.mark.skip
     def test_get(self) -> None:
         self.create_user({"name": "Heisenberg"})
         response = self.retrieve_user("Heisenberg")
 
         assert response == {"data": "My name is Heisenberg"}
 
-    @pytest.mark.skip
     def test_update(self) -> None:
         self.create_user({"name": "Heisenberg"})
 
         response = self.update_user("Heisenberg", {"name": "Jesse"})
         assert response == {"data": "My name is Jesse"}
 
-    @pytest.mark.skip
     def test_delete(self) -> None:
         self.create_user({"name": "Heisenberg"})
         self.delete_user("Heisenberg")
 
         response = self.flask_client.get("/user/Heisenberg")
         assert response.status_code == HTTPStatus.NOT_FOUND
 
-    @pytest.mark.skip
     def test_not_found(self) -> None:
         response = self.flask_client.get("/404")
         assert response.status_code == HTTPStatus.NOT_FOUND

lists/lists.py

@@ -8,7 +8,16 @@ def replace(input_list: list[int]) -> list[int]:
         :param input_list: Исходный список
         :return: Список с замененными элементами
         """
-        pass
+        if not input_list:
+            return input_list
+        max_value = input_list[0]
+        for items in input_list:
+            if items > max_value:
+                max_value = items
+        replaced_list = list(
+            map(lambda replaced: max_value if replaced > 0 else replaced, input_list)
+        )
+        return replaced_list
 
     @staticmethod
     def search(input_list: list[int], query: int) -> int:
@@ -20,4 +29,21 @@ def search(input_list: list[int], query: int) -> int:
         :param query: Искомый элемент
         :return: Номер элемента
         """
-        pass
+        if len(input_list) == 0:
+            return -1
+
+        mid = len(input_list) // 2
+
+        if input_list[mid] == query:
+            return mid
+
+        elif query < input_list[mid]:
+            return ListExercise.search(input_list[:mid], query)
+
+        else:
+            new_mid = mid + 1
+            result = ListExercise.search(input_list[new_mid:], query)
+            if result == -1:
+                return -1
+            else:
+                return mid + 1 + result

maps/maps.py

@@ -13,7 +13,16 @@ def rating(list_of_movies: list[dict]) -> float:
         Ключи словаря: name, rating_kinopoisk, rating_imdb, genres, year, access_level, country
         :return: Средний рейтинг фильмов у которых две или больше стран
         """
-        pass
+        more_2_countries_movies = []
+        for movie in list_of_movies:
+            if (
+                movie["rating_kinopoisk"]
+                and float(movie["rating_kinopoisk"]) != 0
+                and len(movie["country"].split(",")) >= 2
+            ):
+                more_2_countries_movies.append(movie)
+        rating = map(lambda movie: float(movie["rating_kinopoisk"]), more_2_countries_movies)
+        return sum(rating) / len(list(more_2_countries_movies))
 
     @staticmethod
     def chars_count(list_of_movies: list[dict], rating: Union[float, int]) -> int:
@@ -28,4 +37,9 @@ def chars_count(list_of_movies: list[dict], rating: Union[float, int]) -> int:
         :return: Количество букв 'и' в названиях всех фильмов с рейтингом больше
         или равным заданному значению
         """
-        pass
+        rating_movies = []
+        for movie in list_of_movies:
+            if movie["rating_kinopoisk"] and float(movie["rating_kinopoisk"]) >= rating:
+                rating_movies.append(movie)
+        letters = map(lambda movie: movie["name"].count("и"), rating_movies)
+        return sum(letters)