Jak zbudować aplikację do wyszukiwania przepisów za pomocą Pythona

W dzisiejszym świecie, gdzie przepisy kulinarne rozproszone są po rozległych przestrzeniach internetu, a ich wyszukiwanie często przerywane jest natłokiem reklam i nieistotnych odnośników, odnalezienie idealnego przepisu staje się nie lada wyzwaniem. Stworzenie dedykowanej aplikacji do wyszukiwania przepisów to rozwiązanie, które zapewnia użytkownikom spersonalizowane, intuicyjne i pozbawione rozpraszaczy środowisko.

Proces tworzenia tej aplikacji będzie doskonałą okazją do doskonalenia umiejętności w zakresie żądań HTTP, zarządzania kluczami API, obróbki graficznej oraz projektowania intuicyjnych interfejsów użytkownika, włączając w to dynamiczne aktualizacje interfejsu graficznego.

Instalacja niezbędnych modułów: Tkinter, Requests, Pillow i Webbrowser

Do stworzenia aplikacji potrzebne będą moduły Tkinter, Requests, Pillow (PIL) oraz Webbrowser. Tkinter umożliwi budowę aplikacji desktopowej, oferując bogaty zestaw widżetów, które ułatwią projektowanie interfejsu. Aby zainstalować Tkinter, otwórz terminal i wprowadź polecenie:

 pip install tkinter 

Moduł Requests uprości wysyłanie zapytań HTTP i odbieranie odpowiedzi zawierających dane, takie jak kodowanie czy status. Może on posłużyć do wielu zastosowań, od pobierania informacji o identyfikatorze dzwoniącego, po tworzenie aplikacji sprawdzających status witryn internetowych, przeliczników walut czy aplikacji informacyjnych. Aby go zainstalować, uruchom w terminalu:

 pip install requests 

Biblioteka Pillow, będąca rozwinięciem Python Imaging Library (PIL), oferuje szerokie możliwości w zakresie przetwarzania obrazów, w tym ich edycji, tworzenia, konwertowania formatów i zapisywania. Aby zainstalować moduł Pillow, wpisz w terminalu:

 pip install Pillow 

Moduł Webbrowser umożliwi otwieranie dowolnych linków w domyślnej przeglądarce internetowej. Jest on częścią standardowej biblioteki Pythona, więc nie wymaga dodatkowej instalacji.

Uzyskanie klucza API Edamam do wyszukiwania przepisów

Aby uzyskać klucz API Edamam Recipe Search, wykonaj następujące kroki:

  • Przejdź na stronę Edamam i kliknij przycisk „Signup API”. Wypełnij formularz, wybierając plan „Recipe Search API – Developer”.
  • Po zalogowaniu, przejdź do „Konta”, a następnie kliknij „Przejdź do pulpitu nawigacyjnego”.
  • W kolejnym kroku wybierz zakładkę „Aplikacje”, a następnie kliknij „Widok” obok „Recipe Search API”.
  • Skopiuj „Identyfikator aplikacji” i „Klucze aplikacji”, a następnie zapisz je w bezpiecznym miejscu, aby móc użyć ich w kodzie aplikacji.
  • Implementacja funkcjonalności pobierania 5 najlepszych przepisów

    Kompletny kod źródłowy aplikacji do wyszukiwania przepisów napisanej w Pythonie znajdziesz w tym repozytorium GitHub.

    Na początku zaimportuj wszystkie niezbędne moduły. Następnie zdefiniuj funkcję `get_top_5_recipes()`, której celem będzie pobranie tytułów, zdjęć i linków do pięciu przepisów, które najlepiej pasują do zapytania użytkownika. Użyj funkcji `get()` aby odczytać nazwę szukanego dania z pola tekstowego wprowadzonego przez użytkownika.

    Jeśli użytkownik wprowadził nazwę, zdefiniuj podstawowy adres URL dla punktu końcowego wyszukiwania przepisów w API Edamam. Dodatkowo, przekaż skopiowane wcześniej identyfikatory aplikacji oraz klucze, aby autoryzować żądania do API.

     import tkinter as tk
    import requests
    from PIL import Image, ImageTk
    import webbrowser

    def get_top_5_recipes():
    recipe_name = entry_recipe_name.get()
    if recipe_name:
    api_url = "https://api.edamam.com/search"
    app_id =
    app_key =

    Następnie utwórz słownik `params`, który będzie przechowywał parametry wymagane w zapytaniu do API. Ustaw pary klucz-wartość dla `q`, `app_id` i `app_key`, używając wartości uzyskanych wcześniej. Ustal parametry `from` i `to`, aby określić liczbę wyników, które chcesz wyświetlić.

    Wyślij żądanie GET do API Edamam, łącząc adres URL API ze słownikiem `params`. Zapisz odpowiedź i przekształć ją na format JSON. Wywołaj funkcję `clear_recipe_list()`, aby usunąć przepisy z poprzednich wyszukiwań.

            params = {
    "q": recipe_name,
    "app_id": app_id,
    "app_key": app_key,
    "from": 0,
    "to": 5,
    }

    response = requests.get(api_url, params=params)
    data = response.json()
    clear_recipe_list()

    Sprawdź, czy klucz `hits` jest obecny w otrzymanych danych JSON i czy zawiera wyniki wyszukiwania. Jeśli tak, przeiteruj przez wyniki, wyodrębniając informacje o każdym przepisie. Wyślij żądanie GET do URL obrazu, ustawiając parametr `stream` na True, aby włączyć przesyłanie danych strumieniowo.

    Użyj klasy `Image` z modułu Pillow, aby otworzyć pobrany obraz. Zmień jego rozmiar, ustawiając wysokość i szerokość na 200 pikseli, używając metody resamplingu Lanczosa w celu uzyskania wysokiej jakości. Następnie przekształć obraz na obiekt `PhotoImage`, który jest kompatybilny z Tkinter, aby wyświetlić go w interfejsie użytkownika.

            if "hits" in data and data["hits"]:
    for i, hit in enumerate(data["hits"]):
    recipe = hit["recipe"]
    recipe_list.append(recipe)
    recipe_name = recipe["label"]
    recipe_link = recipe["url"]
    image_url = recipe["image"]

    image_response = requests.get(image_url, stream=True)
    image = Image.open(image_response.raw)
    image = image.resize((200, 200), Image.LANCZOS)
    photo_image = ImageTk.PhotoImage(image)

    Budowa struktury aplikacji

    Zdefiniuj trzy etykiety, aby wyświetlić tytuł przepisu, obraz i link do przepisu. Ustaw okno nadrzędne, tekst do wyświetlenia oraz styl czcionki. Aby wyświetlić obraz, ustaw atrybut `image` na `photo_image`. W etykiecie z linkiem ustaw opcję kursora na `hand2`, aby wskazywał, że jest klikalny.

    Powiąż etykietę z linkiem ze zdarzeniem kliknięcia lewym przyciskiem myszy, które wywoła funkcję `open_link()`. Uporządkuj wszystkie widżety za pomocą metody `pack()`, wyśrodkowując je poziomo i dodając marginesy w razie potrzeby. Zapisz tytuły, obrazy i linki do trzech oddzielnych list.

                    recipe_title_label = tk.Label(
    canvas_frame,
    text=f"{i+1}. {recipe_name}",
    font=("Helvetica", 12, "bold"),
    )
    recipe_title_label.pack(pady=(5, 0), anchor=tk.CENTER)

    image_response = requests.get(image_url, stream=True)
    image = Image.open(image_response.raw)
    image = image.resize((200, 200), Image.LANCZOS)
    photo_image = ImageTk.PhotoImage(image)
    image_label = tk.Label(canvas_frame, image=photo_image)
    image_label.image = photo_image
    image_label.pack(pady=(0, 5), anchor=tk.CENTER)

    link_label = tk.Label(
    canvas_frame, text=recipe_link, fg="blue", cursor="hand2"
    )
    link_label.pack(pady=(0, 10), anchor=tk.CENTER)
    link_label.bind(
    "<Button-1>", lambda event, link=recipe_link: open_link(link)
    )

    recipe_labels.append(recipe_title_label)
    recipe_images.append(photo_image)
    recipe_links.append(link_label)

    Zdefiniuj funkcję `clear_recipe_list()`, aby wyczyścić całą zawartość ekranu wygenerowaną przez poprzednie wyszukiwanie. Wyczyść zawartość listy `recipe_list`, a następnie przeiteruj po każdej etykiecie w liście `recipe_labels`.

    Wywołaj metodę `pack_forget()`, aby usunąć etykietę z okna, ale zachować ją w pamięci. Wyczyść listę `recipe_labels`, aby przygotować ją na nowe dane. Powtórz ten proces dla obrazów i linków. Zdefiniuj funkcję `open_link()`, która otworzy link do przepisu w domyślnej przeglądarce.

     def clear_recipe_list():
    recipe_list.clear()
    for label in recipe_labels:
    label.pack_forget()
    recipe_labels.clear()
    for image_label in recipe_images:
    image_label.pack_forget()
    recipe_images.clear()
    for link_label in recipe_links:
    link_label.pack_forget()
    recipe_links.clear()

    def open_link(link):
    webbrowser.open(link)

    Zainicjuj główne okno Tkinter. Ustaw tytuł, wymiary oraz kolor tła aplikacji. Zdefiniuj widżet ramki i ustaw jego rodzica oraz kolor tła. Stwórz etykietę, pole tekstowe i przycisk wyszukiwania. Uporządkuj wszystkie widżety, używając metody `pack()`, dodając marginesy w razie potrzeby.

     root = tk.Tk()
    root.title("Wyszukiwarka Przepisów")
    root.geometry("600x600")
    root.configure(bg="#F1F1F1")

    frame = tk.Frame(root, bg="#F1F1F1")
    frame.pack(fill=tk.BOTH, expand=tk.YES, padx=20, pady=20)

    label_recipe_name = tk.Label(
    frame, text="Wprowadź nazwę przepisu:", font=("Helvetica", 14, "bold"), bg="#F1F1F1"
    )
    label_recipe_name.pack()

    entry_recipe_name = tk.Entry(frame, font=("Helvetica", 12))
    entry_recipe_name.pack(pady=5)

    search_button = tk.Button(
    frame,
    text="Szukaj przepisów",
    font=("Helvetica", 12, "bold"),
    command=get_top_5_recipes,
    )
    search_button.pack(pady=10)

    Utwórz płótno z białym tłem, które posłuży do wyświetlania widżetów zawierających informacje o przepisach. Umieść je po lewej stronie okna, wypełniając całą dostępną przestrzeń i rozszerzając się przy zmianie rozmiaru.

    Dodaj pionowy pasek przewijania do płótna, umieszczając go po jego prawej stronie. Połącz metodę `scrollbar.set` z metodą `canvas.yview`, aby przewijanie paska przewijania wpływało na zawartość płótna.

    Stwórz ramkę wewnątrz płótna, która będzie pojemnikiem na elementy przepisu, zakotwiczając ją w lewym górnym rogu okna. Powiąż zdarzenie ``, aby zapewnić prawidłowe przewijanie, gdy zawartość lub rozmiar ramki ulegną zmianie.

     canvas = tk.Canvas(frame, bg="white")
    canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=tk.YES)

    scrollbar = tk.Scrollbar(frame, orient=tk.VERTICAL, command=canvas.yview)
    scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
    canvas.configure(yscrollcommand=scrollbar.set)

    canvas_frame = tk.Frame(canvas, bg="white")
    canvas.create_window((0, 0), window=canvas_frame, anchor=tk.NW)
    canvas_frame.bind(
    "<Configure>", lambda event: canvas.configure(scrollregion=canvas.bbox("all"))
    )

    Zdefiniuj puste listy `recipe_list`, `recipe_labels`, `recipe_images` i `recipe_links`. Funkcja `mainloop()` informuje Pythona, aby uruchomił pętlę zdarzeń Tkinter i monitorował zdarzenia do czasu zamknięcia okna.

     recipe_list = []
    recipe_labels = []
    recipe_images = []
    recipe_links = []

    root.mainloop()

    Połącz to wszystko i odkrywaj kulinarne inspiracje jednym kliknięciem!

    Wynik działania aplikacji Wyszukiwarka Przepisów

    Po uruchomieniu aplikacji i wpisaniu przykładowo „Chicken Burger”, otrzymasz pięć najlepszych wyników wyszukiwania, w tym tytuł, zdjęcie i link do przepisu. Kliknięcie w link otwiera go w domyślnej przeglądarce. Przewijanie wyników w dół nie powoduje zmiany ich rozmiaru, a wyniki pozostają wyśrodkowane.

    Udoskonalenie aplikacji Wyszukiwarka Przepisów

    Aby rozszerzyć funkcjonalność aplikacji, można dodać opcje filtrowania i sortowania wyników według różnych preferencji. Przepisy można filtrować, uwzględniając preferencje żywieniowe, czas przygotowania czy rodzaj kuchni, a także sortować wyniki w dowolnej kolejności.

    Dobrym rozwiązaniem byłoby także dodanie opcji dodawania przepisów do zakładek, aby można było je łatwo odnaleźć w przyszłości oraz możliwość udostępniania ich w mediach społecznościowych. Dodatkowo, można wprowadzić kategorie, które pozwolą użytkownikom odkrywać najczęściej wyszukiwane, dodawane do zakładek i inne popularne przepisy.

    Łącząc swoje umiejętności programistyczne z zaawansowanymi funkcjami interfejsów API, możesz przekształcić tę bazową aplikację w rozbudowane i kompleksowe narzędzie.


    newsblog.pl