26296624 Project 2023.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "bd439890",
   "metadata": {},
   "source": [
    "# Section A"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47c924a1",
   "metadata": {},
   "source": [
    "# "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff189d7c",
   "metadata": {},
   "source": [
    "### What is a Rest API and how does the interaction take place?\n",
    "\n",
    "A REST API (Representational State Transfer Application Programming Interface) is a set of rules that help different computer systems talk to each other on the internet. It assists in sharing information in a standardized way. This is used to create websites and apps that can work together and share information with each other.\n",
    "    \n",
    "In a REST API, resources are identified by unique URIs (Uniform Resource Identifiers) and can be manipulated using HTTP methods like GET, POST, PUT, DELETE, etc. The API then returns data in a specific format such as JSON or XML.\n",
    "\n",
    "OMDB (Open Movie Database) is a RESTful API that provides a database of movies and TV shows along with information such as ratings, reviews, plot summaries, and more. To interact with the OMDB API using Python, PyPI (Python Package Index) can be used which a useful wrapper for accessing the API, which allows easier access on information about movies and TV shows. Using a package like omdb can save developers time and effort by handling the details of making HTTP requests and parsing the responses, allowing them to focus on using the data returned by the API in their Python code."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2146121",
   "metadata": {},
   "source": [
    "### To use the program, follow these instructions:\n",
    "\n",
    "\n",
    "Once the program has started, a menu with the following choices will be displayed to you:\n",
    "\n",
    "    1. Search By Movie/Series Title\n",
    "    2. Search By Series (Season and Episode)\n",
    "    3. Search By IMDB ID\n",
    "    4. View Previous Search Results\n",
    "    \n",
    "\n",
    "1. To perform a title-based search, choose option 1 from the menu, type the movie or TV show's title into the box that appears, and then press Enter. The program will present details about the movie or TV show that corresponds to the title.\n",
    "\n",
    "\n",
    "2. Choose  option 2 from the menu, type the TV program's name when requested, then press enter to find a TV show . Then when requested, provide the season and/or episode number. The information about the season/episode that corresponds to the input will be shown.\n",
    "\n",
    "\n",
    "3. Choose option 3 from the menu, enter the IMDB ID when requested, then press enter to search for a movie or TV show by its IMDB ID. When an IMDB ID is matched, the application will display details about the movie or TV show.\n",
    "\n",
    "\n",
    "4. Choose option 4 from the menu to examine the list of previously searched movies or TV shows. The program will offer a list of the movies or TV shows that you have already searched for. The program will then prompt you with a box to enter the number of any previosuly searched movie . Where you can enter the number and receive the corresponding details about the movie or TV programme you'd like to view.\n",
    "\n",
    "\n",
    "5. To exit the program, enter 'Quit' when prompted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "213adab3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "----------------------------------\n",
      "Search Menu:\n",
      "----------------------------------\n",
      "1. Search By Movie/Series Title\n",
      "2. Search By Series (Season and episode)\n",
      "3. Search By IMDB ID\n",
      "4. View Previous Search Results\n",
      "Enter 'Quit' to exit\n",
      "-----------------------------------\n",
      "Please enter the number of your choice: quit\n",
      "Goodbye.\n"
     ]
    }
   ],
   "source": [
    "# import the omdb module\n",
    "import omdb \n",
    "\n",
    "\n",
    "#Define a class to search for movies or TV series on OMDB\n",
    "class Movie_Search():\n",
    "    def __init__(self, API_KEY):\n",
    "        #Initialize the object with default values for the search parameters\n",
    "        self.API_KEY = API_KEY\n",
    "        omdb.set_default('apikey', API_KEY)\n",
    "        \n",
    "    # Function to search for a movie or TV series by its title    \n",
    "    def search_title(self, title):\n",
    "        return omdb.title(title)\n",
    "    \n",
    "    # Function to search TV series by its title\n",
    "    def search_series(self, series):\n",
    "        return omdb.get(title = series, fullplot=True)\n",
    "    \n",
    "    # Function to search for a season of a TV series\n",
    "    def search_season(self, series, season):\n",
    "        self.series = series\n",
    "        self.season = season\n",
    "        return omdb.get(title=self.series, season=self.season, fullplot=True)\n",
    "    \n",
    "    # Function to search for a episode of a TV series\n",
    "    def search_episode(self, series, season,  episode):\n",
    "        self.series = series\n",
    "        self.season = season\n",
    "        self.episode = episode\n",
    "        return omdb.get(title=self.series, season=self.season, fullplot=True, episode=self.episode)\n",
    "    \n",
    "    # Function to search for a movie or TV series by its IMDB ID\n",
    "    def search_imdb_id(self, imdb_id):\n",
    "        return omdb.imdbid(imdb_id)\n",
    "    \n",
    "     #Function to display the movie or TV series information to the user   \n",
    "    def display(self, data):\n",
    "        title = data['title']\n",
    "        year = data['year']\n",
    "        rated = data['rated']\n",
    "        released = data['released']\n",
    "        runtime = data['runtime']\n",
    "        genre = data['genre']\n",
    "        director = data['director']\n",
    "        writer = data['writer']\n",
    "        actors = data['actors']\n",
    "        plot = data['plot']\n",
    "        language = data['language']\n",
    "        country = data['country']\n",
    "        awards = data['awards']\n",
    "        poster = data['poster']\n",
    "        ratings = data['ratings']\n",
    "        imdb_rating = data['imdb_rating']\n",
    "        imdb_votes = data['imdb_votes']\n",
    "        imdb_id = data['imdb_id']\n",
    "        \n",
    "        print(f\"Title: {title}\")\n",
    "        print(f\"Year: {year}\")\n",
    "        print(f\"Rated: {rated}\")\n",
    "        print(f\"Realeased: {released}\")\n",
    "        print(f\"Runtime: {runtime}\")\n",
    "        print(f\"Genre: {genre}\")\n",
    "        print(f\"Director: {director}\")\n",
    "        print(f\"Writer: {writer}\")\n",
    "        print(f\"Actors: {actors}\")\n",
    "        print(f\"Plot: {plot}\")\n",
    "        print(f\"Language: {language}\")\n",
    "        print(f\"Country: {country}\")\n",
    "        print(f\"Poster: {poster}\")\n",
    "        print(f\"Awards: {awards}\")\n",
    "        print(f\"IMDB Rating: {imdb_rating}\")\n",
    "        print(f\"IMDB Votes: {imdb_votes}\")\n",
    "        print(f\"IMDB ID: {imdb_id}\")\n",
    "        print(f\"Other Ratings:\")\n",
    "        #Using a seperate for loop to iterate through the \"ratings\" key, as the key's values are kept in dictionary within a list\n",
    "        for rating in ratings:\n",
    "            print(f\"   Source: {rating['source']}\")\n",
    "            print(f\"   Value: {rating['value']}\")\n",
    "            \n",
    "            \n",
    "    #Function to display the TV series' season to the user. \n",
    "    def display_season(self, series):\n",
    "        title = series['title']\n",
    "        season = series['season']\n",
    "        total_seasons = series['total_seasons']\n",
    "        episodes = series['episodes']\n",
    "\n",
    "        print(f\"Title: {title}\")\n",
    "        print(f\"Season: {season}\")\n",
    "        print(f\"Total Seasons: {total_seasons}\")\n",
    "        print(\"Episodes:\")\n",
    "    #Using a seperate for loop to iterate through the \"episodes\" key, as the key's values are kept in dictionary within a list\n",
    "        for episode in episodes:\n",
    "            print(f\"Title: {episode['title']}\")\n",
    "            print(f\"Episode Number: {episode['episode']}\")\n",
    "            print(f\"Released: {episode['released']}\")\n",
    "            print(f\"IMDb Rating: {episode['imdb_rating']}\")\n",
    "            print(f\"IMDb ID: {episode['imdb_id']}\")\n",
    "            print(\"\")\n",
    "                \n",
    "# Define a class to manage the search history of the users input\n",
    "class Movie_History:\n",
    "    def __init__(self):\n",
    "        pass\n",
    "    \n",
    "# Function to write the searched movie or TV series to a file\n",
    "    def write_to_file(self, movie_title):\n",
    "        with open(\"movie_search_history.txt\", \"a\") as f:\n",
    "            f.write(f\"{movie_title}\\n\")\n",
    "\n",
    "    # Function to read the movie search history of the user from the file\n",
    "    def read_from_file(self):\n",
    "        try:\n",
    "            with open(\"movie_search_history.txt\", \"r\") as f:\n",
    "                return f.readlines()\n",
    "        except FileNotFoundError:\n",
    "            return []\n",
    "\n",
    " # Function to display the list of previously searched movies or TV series to the user \n",
    "        search_history = self.read_from_file()\n",
    "        if not search_history:\n",
    "            print(\"No movies searched yet.\")\n",
    "        else:\n",
    "            print(\"Search history:\")\n",
    "            for index, movie in enumerate(search_history, start=1):\n",
    "                print(f\"{index}. {movie}\", end=\"\")\n",
    "            print(\"\")\n",
    "        \n",
    " #Main program search loop    \n",
    "while True: \n",
    "    print(\"----------------------------------\")\n",
    "    print(\"Search Menu:\")\n",
    "    print(\"----------------------------------\")\n",
    "    print(\"1. Search By Movie/Series Title\")\n",
    "    print(\"2. Search By Series (Season and episode)\")\n",
    "    print(\"3. Search By IMDB ID\")\n",
    "    print(\"4. View Previous Search Results\")\n",
    "    print(\"Enter 'Quit' to exit\")\n",
    "    print(\"-----------------------------------\")\n",
    "    \n",
    "    #Get the users choice\n",
    "    choice = input(\"Please enter the number of your choice: \")\n",
    "    \n",
    "    #Create objects of the Movie_Search and Movie_History classes\n",
    "    API_KEY = 'c46aae93'\n",
    "    movie = Movie_Search(API_KEY)\n",
    "    history = Movie_History()\n",
    "   \n",
    "    \n",
    "    #If user chooses choice 1, a movie or TV series title can be entered\n",
    "    if choice == '1': \n",
    "        title = input(\"Enter the Title: \")\n",
    "        display_movie = movie.search_title(title) \n",
    "     \n",
    "    #Use of conditionals determine if the title is valid, otherwise an error message is displayed\n",
    "        if not title:\n",
    "            print()\n",
    "            print(\"Invalid Movie/Series Title, please try again.\")\n",
    "        \n",
    "        elif not display_movie:\n",
    "            print()\n",
    "            print(\"Movie/Series not found, please try again.\")\n",
    "       \n",
    "    #Displaying the movie/TV Series information using the Movie_Search display function\n",
    "    #Writing the searched movie/TV series title to the txt. file using the Movie_history class, write_to_file function\n",
    "        else:\n",
    "            print()\n",
    "            movie.display(display_movie)\n",
    "            history.write_to_file(title)\n",
    "            \n",
    "  \n",
    "     \n",
    "    #If user chooses choice 2, TV series title can be entered          \n",
    "    elif choice == '2':\n",
    "        series = input(\"Enter the TV Series name: \")\n",
    "        display_series = omdb.get(title = series, fullplot=True)\n",
    "     \n",
    "    # Use of conditionals to determine if the TV series title is valid, otherwise an error message is displayed\n",
    "        if not series:\n",
    "            print(\"Invalid Series Title, please try again.\")\n",
    "            continue\n",
    "    \n",
    "        elif len(series) > 0:\n",
    "            if not display_series:\n",
    "                print(\"Series not found, please try again.\")\n",
    "\n",
    "    #if the title is valid, the season number prompt is displayed\n",
    "    # With the use of the While loop, the prompt will keep displaying until a valid season number is entered\n",
    "            else:\n",
    "                while True:\n",
    "                    ss = input(\"Enter the season number: \")\n",
    "                    display_season = omdb.get(title=series, season=ss, fullplot=True)\n",
    "                    if not display_season:\n",
    "                        print(\"Please enter a valid season number.\")\n",
    "                    else:\n",
    "                        break  # break out of the while loop when a valid season number is entered\n",
    "\n",
    "                # the code continues run where an episode number can be entered, where the same While loop is used\n",
    "\n",
    "       \n",
    "                while True:\n",
    "                    epi = input(\"Enter the episode number or leave blank for the full season : \")\n",
    "                    display_episode = omdb.get(title=series, season=ss, fullplot=True, episode=epi)\n",
    "\n",
    "                    if not display_episode:\n",
    "                        print(\"Please enter a valid episode number.\")\n",
    "                    else:\n",
    "                        break\n",
    "\n",
    "                #If the episode and season number is kept blank, just the series information will be displayed\n",
    "                if epi == \"\" and ss == \"\" :\n",
    "                    print()\n",
    "                    movie.display(display_series)\n",
    "                    history.write_to_file(series) \n",
    "                    \n",
    "                #If the episode number is kept blank, just the season information will be displayed\n",
    "                elif epi== \"\":\n",
    "                    print()\n",
    "                    movie.display_season(display_season)\n",
    "                    history.write_to_file(series)\n",
    "\n",
    "                else:\n",
    "                    print()\n",
    "                    movie.display(display_episode)\n",
    "                    history.write_to_file(series)\n",
    "                    \n",
    "\n",
    "    #If user chooses choice 3, the IMDB ID can be entered         \n",
    "    elif choice == '3':\n",
    "        imdb_id = input(\"Enter the IMDB ID: \")\n",
    "        display_id = movie.search_imdb_id(imdb_id)\n",
    "        \n",
    "        if not imdb_id:\n",
    "            print(\"Invalid IMDB ID, please try again.\")\n",
    "        \n",
    "        elif not display_id:\n",
    "            print(\"Invalid IMDB ID, please try again.\")\n",
    "       \n",
    "        else:\n",
    "            print()\n",
    "            movie.display(display_id)\n",
    "            history.write_to_file(imdb_id)\n",
    "            \n",
    "            \n",
    "    #If user chooses choice 4, previously searched movie/series titles are displayed   \n",
    "    elif choice == '4':\n",
    "        try:\n",
    "            # Read the previously searched movies from a text file\n",
    "            with open(\"movie_search_history.txt\", \"r\") as f:\n",
    "                movie_searches = f.readlines()\n",
    "\n",
    "            # Display the list of previously searched movies\n",
    "            print(\"Previously searched movies:\")\n",
    "            for i, movie in enumerate(movie_searches):\n",
    "                print(f\"{i+1}. {movie}\")\n",
    "\n",
    "            # Ask the user to select a movie/TV series to view\n",
    "            movie_num = input(\"Enter the number of the movie you want to view : \")\n",
    "            movie_num = int(movie_num)\n",
    "\n",
    "            if 1 <= movie_num <= len(movie_searches):\n",
    "               \n",
    "                selected_movie = movie_searches[movie_num-1].strip()\n",
    "\n",
    "                # Create an instance of the Movie_Search class\n",
    "                movie_search = Movie_Search(API_KEY)\n",
    "\n",
    "                # Get the data of the selected movie/TV series title or movie/ TV series IMDB ID from OMDB, using the Movie_Search class\n",
    "                \n",
    "                selected_movie_data = movie_search.search_title(selected_movie) or movie_search.search_imdb_id(selected_movie)\n",
    "\n",
    "                # Display the data of the selected movie/Tv series, using the display function from the Movie_Search class\n",
    "                movie_search.display(selected_movie_data)\n",
    "\n",
    "\n",
    "            else:\n",
    "                print(\"Invalid movie number. Please try again.\")\n",
    "\n",
    "        # If the file of previously searched movies is not found, print a message\n",
    "        except FileNotFoundError:\n",
    "            print(\"No previously searched movies found.\")\n",
    "        \n",
    "\n",
    " #If \"quit\" is entered, program will exit the loop      \n",
    "    elif choice.lower() == 'Quit'.lower():\n",
    "        print(\"Goodbye.\")\n",
    "        break\n",
    "              \n",
    "    else:\n",
    "        print(\"Invalid choice. Please try again.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3498483",
   "metadata": {},
   "source": [
    "# Section B"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1ab00be",
   "metadata": {},
   "source": [
    "### Intouction to the program:\n",
    "This program allows you to search for movies or TV series using the OMDB(Open Movie Database) API. You can search by movie/series title. TV series with season and episode details, or by IMDB ID.\n",
    "\n",
    "Here are some key design decisions in this program:\n",
    "\n",
    "\n",
    "1. OMDB Module: The program makes use of the omdb module, which offers a straightforward interface for gaining access to the OMDB API. This module enables HTTP queries to the OMDB API endpoints for the retrieval of movie and TV series data.\n",
    "\n",
    "\n",
    "2. Movie_Search Class:  Serves as the key component for searching  movies or TV shows . It has tools for searching by IMDB ID, title, series, season, or episode. In order to show the user the data that was retrieved, it also contains a display function to present the user with the particular information.\n",
    "\n",
    "\n",
    "3. Movie_History Class: This class is in charge of handling user search history. It has features for saving searched TV series or movies to a file as well as reading the search history from that file. The search history is displayed to the user upon request.\n",
    "\n",
    "\n",
    "4. Main Programme Loop: The user can choose the desired search option from a menu presented to them by the main programme loop. The appropriate methods from the Movie_Search and Movie_History classes are then called using the user's selection. The user's search history is updated while the search results are shown.\n",
    "\n",
    "\n",
    "5. Basic input validation is carried out by the programme to make sure that the user enters valid data. For instance, the programme displays the proper error message if an invalid title, season, episode, or IMDB ID is entered.\n",
    "\n",
    "\n",
    "6. User-Friendly Output: By structuring the acquired movie or TV series data, the programme produces user-friendly output. Title, year, rating, runtime, genre, director, plot, language, country, awards, poster, ratings, IMDB rating, IMDB votes, and IMDB ID are just a few of the information that is displayed. To improve the user's experience, the information is presented in a clear manner.\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be8972b7",
   "metadata": {},
   "source": [
    "### An Overview of how data was collected for the program:\n",
    "\n",
    "The OMDB (Open Movie Database) API was utilized for the necessary data in this program. As mentioned prior the OMDB API serves as an avenue for obtaining movie and TV series data. With a structure that remains RESTful, the OMDB API supplies an expansive repository of movie and TV series information. This web service's endpoints can be utilized to access exact information about episodes, seasons, movies, TV series, and other related data\n",
    "\n",
    "In order to interact with the OMDB API, the omdb module—which serves as a wrapper—was imported. This module facilitates the handling of HTTP requests to the OMDB API and responses.\n",
    "\n",
    "Using the omdb module, I managed to obtain data via a range of methods. One of these involved utilizing the omdb.title() method to locate TV shows or movies by their titles. Once I fed the method with the relevant title, it promptly queried the OMDB API and returned the resulting data.\n",
    "\n",
    "Using the omdb.get() method, I retrieved information about TV shows via parameters like name, season, and episode. By providing the title of the series, its episode number and season, the method was able to fetch the relevant data from the OMDB API.\n",
    "\n",
    "By utilizing the omdb.imdbid() method, I managed to locate films or television programs by their IMDB IDs and consequently extract relevant information. Using the IMDB ID as the method's input parameter facilitated the direct retrieval of data.\n",
    "\n",
    "From the OMDB API's dataset, discover the cast, awards, director, plot, poster, rating, release year, and other assorted details about movies and television programs.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ac5c66f",
   "metadata": {},
   "source": [
    "### Retrospective:\n",
    "\n",
    "I faced a few obstacles while creating this program, Understanding the OMDB API's usage and structure proved to be one of the early challenges. To understand the available endpoints, parameters, and response formats, I had to carefully read the API documentation. To correctly query the API for various types of searches, some trial and error was necessary.\n",
    "\n",
    "I also made use of Object Orientated Programming, which required research and understanding of how objects could be created in relation to the OMDB API and its data.\n",
    "\n",
    "Another challenge was handling invalid or incorrect user inputs. I implemented conditional checks to validate the user's input for movie titles, series titles, season numbers, episode numbers, and IMDB IDs. If the input was invalid, appropriate error messages were displayed to guide the user.\n",
    "\n",
    "Additionally, I faced a challenge in formatting and displaying the retrieved data from the API in a user-friendly manner. I developed the display() and display_season() methods to extract the required information from the API response and present it in a readable format. This required accessing nested dictionaries and lists within the API response in order to extract the necessary data.\n",
    "\n",
    "Improvements:\n",
    "\n",
    "In the following areas, the program could be strengthened:\n",
    "\n",
    "Error handling: The program handles input errors in a basic way, but it could be improved to show more thorough error messages. Then, users could fix their mistakes and learn from them.\n",
    "\n",
    "A more user-friendly user interface would improve the program's usability. Users would be guided in providing the necessary inputs and understanding the available options if prompts and instructions were added throughout the program. In order to improve the user experience, I would also take into account a graphical user interface (GUI).\n",
    "\n",
    "There is currently only a small amount of exception handling in the program. More robust exception handling should be put in place to deal with potential errors like problems with network connectivity or incorrect OMDB API responses.\n",
    "\n",
    "Learning Experience:\n",
    "\n",
    "I learned a great deal a about working with APIs, handling API responses, and creating a command-line interface for user interaction while creating this program. Additionally, I gained a better understanding of Python's handling of files, HTTP requests, responses, and errors.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a905ed3c",
   "metadata": {},
   "source": [
    "### Help :\n",
    "\n",
    "Follow these steps to use this program:\n",
    "\n",
    "\n",
    "Make sure all required dependencies, including the omdb module, are installed.\n",
    "\n",
    "Get an API key by creating a free account on the OMDB API website (http://www.omdbapi.com). Replace the API_KEY variable in the code with your actual API key once you have it.\n",
    "\n",
    "Utilize a Python environment to run the program.\n",
    "\n",
    "The program will display a search menu with several choices:\n",
    "\n",
    "Choice Making:\n",
    "- Possible errors: \n",
    "    - An error message will be shown if any choice other than choices (1–4) or \"Quit\" is \n",
    "\n",
    "a. Choice 1: Search By Movie/Series Title:\n",
    "- Enter the title of the movie or TV series you want to search. The program will display the relevant information if found.\n",
    "\n",
    "- Possible errors:\n",
    "    - If the title is invalid or not found, an error message will be displayed\n",
    "\n",
    "\n",
    "\n",
    "b. Choice 2: Search By Series (Season and episode):\n",
    "- Enter the title of the TV series you want to search. Then provide the season number and episode number. The program will display the corresponding episode information or the full season information if the episode number is left blank.\n",
    "\n",
    "- Possible errors:\n",
    "    - If the series title is invalid or not found, an error message will be displayed.\n",
    "    - If the season number is invalid, an error message will be displayed.\n",
    "    - If the season or episode information is not found, an error message will be displayed\n",
    "\n",
    "\n",
    "c. Choice 3: Search By IMDB ID:\n",
    "- Enter the IMDB ID of the movie or TV series you want to search. The program will display the relevant information if found.\n",
    "\n",
    "- Possible errors:\n",
    "    - If the IMDB ID is invalid or not found, an error message will be displayed.\n",
    "\n",
    "\n",
    "d. Choice 4: View Previous Search Results:\n",
    "- This option displays a list of previously searched movies or TV series. You can select a specific item from the list to view its details.\n",
    "\n",
    "- Possible errors:\n",
    "    - If no previous search history is found, a message will be displayed.\n",
    "    - If the selected movie or series is not found, an error message will be displayed.\n",
    "\n",
    "\n",
    "e. Enter 'Quit' to exit the program.\n",
    "\n",
    "\n",
    "Follow the prompts and input the required information as instructed.\n",
    "\n",
    "The program will display the relevant information or error messages based on the search results.\n",
    "\n",
    "Make sure to use valid titles, season numbers, episode numbers, and IMDB IDs for accurate results.\n",
    "\n",
    "Note: The program saves the search history to a text file named \"movie_search_history.txt\" in the same directory"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}