A

PROJECT REPORT

ON

“Book Recommendataion System”

SUBMITTED

TO

SAVITRIBAI PHULE PUNE UNIVERSITY, PUNE

FOR THE PARTIAL FULFILLMENT OF

MASTER OF COMPUTER APPLICATION

(MCA-I, SEM.-I)

BY

GAUTAM GANESH VELU

UNDER THE GUIDANCE OF

Dr. Poonam Sawant

1
 CERTIFICATE
This is to certify that, the project entitled
“BookRecommendation”, being submitted for the partial fulfilment of
the degree of Master of Computer Application by her/him to Sinhgad
Institute of Management and Computer Application affiliated to
Savitribai Phule Pune University, Pune is the result of the original work
completed by Gautam Ganesh Velu under the guidance of Dr. Poonam
Sawant
To the best of our knowledge and belief, this work has not been
previously submitted by the award of any degree or diploma of
Savitribai Phule Pune University or any other University.

PLACE: PUNE

DATE: / /

Dr. Poonam Prof. Navanath Dr. Rajesh Gawali Dr. Vijaya Puranik
Sawant Choudhari

Internal Guide Project Co- Academic Director SIMCA

Ordinator Coordinator

Internal Examiner

2
 DECLARATION

I, the undersigned hereby declare that the project titled “Book

Recommendation System” being submitted for the award of degree of
Master of Computer Application by me to Sinhgad Institute of
Management and Computer Application(SIMCA) affiliated to
Savitribai Phule Pune University is the result of an independent work
carried out under the guidance of Dr. Poonam Sawant, is my original
work . Further I declare that this project has not been submitted to this
or any Institution for the award of any degree.

PLACE: PUNE GAUTAM GANESH VELU

DATE: / / (Student)

3
 ACKNOWLEDGEMENT

I consider it a privilege to express few words of gratitude and respect to

all who guided and inspired me in successful completion of this project.
I acknowledge my profound indebtedness and extend my deep sense of
gratitude to my Project Guide Dr. Poonam Sawant for sharing their
knowledge and experience and providing valuable guidance, profound
advice and encouragement that has led to successful completion of this
project.
I take this opportunity to thank my, project coordinator Dr. Poonam
Sawant and our Director Dr. Vijaya Puranik, for encouragement and
guidance throughout the progress of this report.

GAUTAM GANESH VELU

4
 Book
Recommendation
System

5
Sr. NO INDEX PG.NO
1. Introduction 8
1.1 Abstract 9
1.2 Existing System and Need for System 10
1.3 Objective Of Project 12
1.4 Future Scope 14
1.5 System Overview 15
1.6 Requirement And Specification 16
2. Proposed System 17
2.1 Study of Similar Systems (If required research paper can be 17
included)
2.2 Feasibility Study 21
2.3 Objectives of Proposed Project 25
3. Analysis and Design 27
3.1 System requirements (Functional and Non-Functional 27
requirements)
3.2 Use Case Analysis 29
3.3 Architectural Design 30
3.4 Class Diagram 30
3.5 Sequence Diagram 31
3.6 Flow Chart 32
3.7 Component design 33
4. Coding 34
4.1 Algorithms 35
4.2 Code Snippets 38
5. Testing 50
5.1 Unit testing 50
5.2 Integration Testing 51
5.3 System Testing 51
5.4 User Acceptance Testing(UAT) 52
5.5 Performance Test 52
5.6 Tool used 52
5.7 Test Case 53
6. Implementation 54
6
 7. Limitations of Proposed system 58
8. Proposed Enhancements 61
9. Bibliography 65
10. User Manual (All screens with proper
description/purpose Details 68
about validations related to data to be entered.)
11. Conclusion 76

1.Introduction

7
Python Project to Recommend Books Using a JSON Database
This project involves the development of a book recommendation
system using Python and Tkinter for the GUI. The tool is designed to
recommend books based on user preferences and search queries. The
system fetches data from the Google Books API and displays the top 5
related books.

In today's digital era, the abundance of available information can often

overwhelm individuals seeking specific content, particularly in the
realm of books. With countless titles across various genres and subjects,
finding the right book can be a daunting task. To address this challenge,
we developed a Book Recommendation System that leverages the
power of the Google Books API and a user-friendly Tkinter GUI to
simplify the book discovery process.

1.1 ABSTRACT

8
This report presents the development of a Book Recommendation
System utilizing Python and Tkinter for the GUI. The project aims to
provide an efficient and user-friendly platform for users to discover
books based on their preferences. Leveraging the Google Books API,
the system retrieves comprehensive data on books, including details
such as authors, publishers, publication dates, and ratings. The GUI
displays the top 5 related books in a visually appealing manner, with
additional optional features like publication dates and ratings to enhance
user experience.

The system addresses the growing need for personalized book

recommendations in a digital age where vast amounts of information
can be overwhelming. By offering a simple search interface, the system
helps users quickly find relevant books, saving time and effort. The
project also explores the integration of various data points to provide a
rich and informative recommendation. Additionally, the use of a JSON
database ensures efficient data handling and storage, contributing to the
overall performance and responsiveness of the application.

The project is structured to allow for future enhancements, including the

incorporation of advanced recommendation algorithms and user profile
management. These improvements aim to further personalize the
recommendations and improve user engagement. Overall, this Book
Recommendation System serves as a foundational tool for exploring the
potential of automated recommendations in the literary domain.

1.3 Existing System and Need for System

9
Existing System
The existing system for book recommendations is either manual or
fragmented across multiple platforms, such as libraries, bookstores, or
online retailers. These systems face several limitations:
1. Manual Searching: Users often need to search for books through
catalogs, websites, or recommendations, which can be time-
consuming and inefficient.
2. Limited Customization: Existing systems may not offer options to
filter results by criteria such as ratings, publication dates, or
specific genres.
3. Static Recommendations: Many systems rely on predefined lists
or basic algorithms that do not dynamically consider user input or
preferences.
4. Poor Integration: Separate systems (e.g., library catalogs and
online stores) do not provide a unified user experience.
5. Lack of Visual Appeal: Traditional systems might not include
intuitive GUIs or appealing visual displays, such as book covers or
additional metadata.

Need for the System

10
The need for this Book Recommendation System stems from addressing
the above challenges with a modern, user-friendly, and efficient
solution:
1. Ease of Use: A graphical user interface (GUI) allows users to
quickly search for books by title or keyword, making the process
seamless and intuitive.
2. Enhanced Customization: The system offers filters (e.g., by
publication date and rating) to help users tailor results to their
preferences.
3. Unified Access: Integrating with the Google Books API provides
access to a vast library of books in one place, reducing the need to
use multiple platforms.
4. Dynamic and Relevant Results: The system fetches real-time data
from the API, ensuring that users receive up-to-date and
personalized book recommendations.
5. Engaging Visual Design: The GUI displays book covers, titles,
and other metadata in an attractive format, improving user
engagement.
6. Automation: By automating the recommendation process, the
system saves time and reduces user effort compared to manual
searches.
This system bridges the gap between fragmented existing solutions and
the need for an efficient, visually appealing, and comprehensive book
recommendation experience.

1.3 OBJECTIVE OF PROJECT

11
The primary objective of this project is to create a system that not only
recommends books based on user queries but also provides
comprehensive information about each recommended book. By
integrating various data points such as author names, publication dates,
and ratings, the system offers a rich and informative user experience.
This project aims to enhance the traditional book search process,
making it more efficient and enjoyable for users.

The system is designed to fetch and display the top 5 books related to
the user's search query. Each recommendation is presented in a separate
frame within the GUI, showcasing key details such as the book cover,
title, author, and optional features like the publication date and rating.
This structured presentation helps users quickly assess and compare the
recommended books.
Our approach to developing this system involves several key
components:
 Data Retrieval: Utilizing the Google Books API, the system
retrieves detailed information about books matching the user's
search query. The API provides a wealth of data, including
author names, subtitles, publishers, publication dates,
descriptions, page counts, print types, categories, images,
languages, countries, list prices, buy links, web reader links, and
search info.

 Data Handling: The retrieved data is processed and stored in a

JSON format, ensuring efficient and flexible data management.
This allows the system to quickly access and display the
necessary information in response to user queries.

12
  GUI Development: Using Python's Tkinter library, the system
features a clean and intuitive interface. The main window is
divided into five frames, each dedicated to one of the top 5
recommended books. Users can easily navigate the interface,
view detailed information, and make informed decisions about
which books to explore further.

 Optional Features: To enhance the user experience, the system

includes optional features such as displaying publication dates
and ratings. These additional data points provide users with
more context and help them make better-informed choices.

This project is a step towards creating more personalized and efficient

book recommendation systems. By focusing on user needs and
leveraging advanced data retrieval techniques, we aim to simplify the
book discovery process and make it more enjoyable. The system's
design allows for future enhancements, including the integration of
advanced recommendation algorithms and user profile management,
to further improve the accuracy and personalization of
recommendations.

13
 1.4 FUTURE SCOPE
Enhanced Recommendation Algorithm:
Integrating advanced recommendation algorithms such as collaborative
filtering and content-based filtering to improve the accuracy of
recommendations.

User Profiles:
Implementing user profiles to store user preferences and improve
personalized recommendations.

Integration with Other APIs:

Expanding the system to integrate with other book-related APIs to
provide a wider range of data and improve the recommendation quality.

14
 1.5 SYSTEM OVERVIEW
Main Features:

1. Search System: Allows users to search for books using keywords.

2. Poster Indication: Displays the book covers in the recommendation
results.
3. Optional Features: Users can choose to view additional information
such as publication dates and ratings.

Data Retrieval:

The system retrieves data from the Google Books API, which includes
details such as author names, subtitles, publishers, publication dates,
descriptions, page counts, print types, categories, images, languages,
countries, list prices, buy links, web reader links, and search info.

Packages Used:

 Pillow == 11.0.0
 Requests == 2.32.3
 pytk == 0.0.2.1


15
 1.6 Requirement and Specification

Hardware Requirements:
PROCESSOR : Intel(R) Core (TM)i5-4300G1
[email protected], 2501 MHz
HARD DISK : 500 MB
RAM : 8 GB

Software Requirements:
OPERATING Window7/8/10/11 , Linux, Mac etc
SYSTEM:
PROGRAMMIN Python (version 3.10.5)
G LANGUAGE :
IDE USED : Visual Studio

16
 2.Proposed System
2.1 Study Of Similar Systems
The Book Recommendation System project falls into a well-researched
domain where similar systems have been developed for recommending
books, movies, music, and other media content. These systems typically
use algorithms and databases to analyze user preferences and suggest
relevant items. Below is a study of similar systems, outlining their key
features, technologies used, and how they compare to the proposed
Book Recommendation System.

1. Google Books API

Description: Google Books offers an API that allows developers to
access its vast library of books and retrieve detailed metadata, such as
titles, authors, publication dates, ratings, and images. It is one of the
most widely used services for integrating book data into third-party
applications.
Key Features:
Real-time access to millions of books.
Includes metadata such as title, author, publisher, publication date, and
book cover images.
Search by title, author, publisher, and ISBN.
Technology: RESTful API, JSON responses.
Comparison to Proposed System: The proposed system integrates the
Google Books API, leveraging its robust search capabilities to provide
real-time book recommendations based on user queries.
2. Goodreads Recommendation System
17
Description: Goodreads is a popular social media platform for book
lovers. It recommends books based on user reviews, ratings, and
interactions within the platform. Goodreads also offers an API for
developers to fetch data on books, authors, and user-generated content.
Key Features:
Personalized book recommendations based on past ratings, genres, and
social interactions.
User reviews and ratings help improve recommendations.
Extensive user-based data, including book collections and wishlists.
Technology: RESTful API, user-based collaborative filtering, and
content-based recommendation algorithms.
Comparison to Proposed System: Unlike the proposed system, which
relies solely on Google Books API and basic filtering, Goodreads uses
more advanced collaborative filtering and content-based algorithms to
personalize recommendations based on user behavior. However, the
proposed system focuses more on a simplified user interface for quick
searches and recommendations.
3. Amazon's Book Recommendation System
Description: Amazon’s recommendation engine is well-known for
suggesting products based on user purchases, searches, and browsing
history. Its book recommendations are heavily based on user behavior,
such as previous purchases, browsing history, and ratings.
Key Features:
Personalized product recommendations based on user behavior (e.g.,
previous purchases, browsing history).
Incorporates collaborative filtering and machine learning algorithms.
18
Provides options for reviewing books, which influences future
recommendations.
Technology: Machine learning, collaborative filtering, data mining.
Comparison to Proposed System: While Amazon uses advanced
machine learning techniques to personalize book recommendations, the
proposed system leverages a simpler approach using real-time data from
the Google Books API. The focus of the proposed system is on
simplicity, ease of use, and visually appealing book displays, rather than
complex personalized recommendations.
4. Bookish (Social Book Recommendation Platform)
Description: Bookish is a platform where users can get book
recommendations based on genre preferences, previous readings, and
user-generated tags. It also allows users to create a wish list of books
they want to read and share their thoughts through reviews.
Key Features:
Provides book recommendations based on user preferences, tags, and
social interactions.
Allows users to connect with others, share recommendations, and post
reviews.
Offers personalized book lists and book clubs.
Technology: Collaborative filtering, social networking features, user
preferences.
Comparison to Proposed System: The proposed Book Recommendation
System does not incorporate social networking or user-generated tags
but focuses on delivering quick and clear book recommendations. It
emphasizes simplicity, real-time search, and a visual interface, which
differs from Bookish’s social and personalized nature.
19
Research Papers and Studies on Book Recommendation Systems
"A Survey of Collaborative Filtering Techniques" by P. Resnick et
al. (1994)
Relevance: While the proposed system does not implement
collaborative filtering, understanding this technique is useful for future
expansions of the system, such as personalized book recommendations.
"Content-Based Recommendation Systems" by M. Pazzani and D.
Billsus (2007)
Relevance: The proposed system is based on a content-based approach
(using metadata from Google Books API), and this paper provides
foundational knowledge on how to refine content-based
recommendation algorithms.
"A Survey of Recommender Systems in e-Commerce" by Jannach
and Adomavicius (2016)

20
2.2 Feasability Study
The feasibility study evaluates the technical, operational, economic, and
scheduling aspects of implementing the Book Recommendation System
to ensure its practicality and success.
1. Technical Feasibility
This aspect determines whether the project is technically possible with
available tools and resources.
 Platform and Tools:
o The system uses Python's Tkinter library for the GUI.
o Integration with the Google Books API ensures access to a
vast library of books.
o Additional libraries like requests, Pillow, and urllib.parse
enhance functionality (e.g., HTTP requests, image handling).
 Technical Requirements:
o A system with Python installed and basic libraries available.
o Access to the internet for API integration.
 Conclusion:
o The project is technically feasible as it uses mature, well-
documented tools and APIs that are widely supported.

21
2. Operational Feasibility
This aspect assesses whether the system meets user needs and how
efficiently it can be operated.
 Ease of Use:
o The graphical interface is simple and intuitive, making it
accessible for non-technical users.
o Features such as search filters (e.g., ratings, publication dates)
enhance user interaction.
 Reliability:
o Real-time data fetching ensures the system remains relevant
and up-to-date.
o Error handling mechanisms (e.g., API failure notifications)
improve usability.
 User Acceptance:
o The system is tailored to meet user demands for quick and
accurate book recommendations, likely ensuring high
adoption rates.
 Conclusion:
o The project is operationally feasible as it aligns with user
expectations and provides a seamless experience.

22
3. Economic Feasibility
This aspect evaluates whether the project is cost-effective in terms of
development and maintenance.
 Cost Factors:
o Development Costs: Minimal, as the system uses free
libraries and APIs.
o Maintenance Costs: Low, requiring only periodic updates
and API monitoring.
o Hardware Requirements: The system can run on standard
hardware with no specialized needs.
 Benefit Analysis:
o Time saved for users searching for books across multiple
platforms.
o Improved user engagement through an interactive, visually
appealing GUI.
 Conclusion:
o The system is economically feasible due to its low
development and maintenance costs and high potential
benefits.

23
4. Scheduling Feasibility
This aspect evaluates whether the project can be completed within a
reasonable timeframe.
 Estimated Time:
o Requirement Gathering and Design: 1-2 weeks.
o Development: 3-4 weeks, including GUI design and API
integration.
o Testing and Debugging: 1-2 weeks.
o Deployment: Less than 1 week.
 Conclusion:
o The project can be completed within 6-8 weeks, making it
feasible in terms of scheduling.

24
2.3 Objective of the Proposed System
The objective of the proposed Book Recommendation System is to
provide an efficient, user-friendly, and visually appealing platform for
users to search for and discover books based on their preferences. The
system aims to enhance the book recommendation experience by
integrating advanced search capabilities, real-time data, and
customizable filters. Specifically, the objectives are:

Primary Objectives
1. Streamline Book Discovery
Enable users to quickly search for books using keywords such as
titles, authors, or genres, reducing the time and effort involved in
manual searches.
2. Provide Dynamic Recommendations
Utilize the Google Books API to fetch up-to-date book
information, ensuring the recommendations are relevant and
current.
3. Enhance User Experience
Offer a clean and intuitive graphical interface (GUI) that is easy to
navigate for users of all technical backgrounds.

25
Secondary Objectives
4. Incorporate Customization
Provide filtering options, such as publication dates and ratings,
allowing users to refine their search results according to their
preferences.
5. Deliver Visual Appeal
Display book covers, titles, and metadata in a visually engaging
format to improve user interaction and satisfaction.
6. Automate the Recommendation Process
Automatically retrieve, process, and display book data to save
user effort and provide a seamless experience.
7. Ensure Scalability
Design the system to be extensible, enabling future integration
with additional APIs, user accounts, and features like reviews or
wish lists

26
 3.Analysis and Design
The analysis phase identifies the requirements and key aspects of the
system to ensure its effectiveness and user satisfaction.

3.1 Functional Requirements

1. Search Functionality:
o Users must be able to search for books by title, author, or
keyword.
o Results must display metadata, including the title, author,
publication date, and ratings.
2. Integration with Google Books API:
o Fetch real-time book data such as images, titles, authors, and
ratings from the Google Books API.
3. Filters:
o Users can apply filters like publication date and ratings to
refine the results.
4. Error Handling:
o Notify users if the API call fails or no results are found.
5. Dynamic Results:
o Update the GUI dynamically based on user searches and
applied filters.

Non-Functional Requirements
27
 1. Usability:
o The GUI must be simple and intuitive, suitable for users of all
technical levels.
2. Performance:
o The system must fetch and display results within a few
seconds.
3. Scalability:
o The system should be extensible to support additional
features, such as user accounts or integration with other APIs.
4. Maintainability:
o Code should be modular and well-documented for easy
updates and debugging.

3.2 Use Case Analysis

28
Actors:
 User: The individual using the system to search for books.
 Google Books API: External system providing book data.
Use Cases:
1. Search for Books:
o Input: Search keyword.
o Output: List of books with metadata.
2. Apply Filters:
o Input: Publication date or rating selection.
o Output: Filtered book results.
3. View Book Details:
o Input: Book selection.
o Output: Expanded view with detailed metadata.
4. Handle Errors:
o Input: Invalid query or API failure.
o Output: Error message displayed to the user.

Design
29
The design phase outlines the architecture, system components, and
interactions.

3.3 Architectural Design

The system follows a Client-Server Architecture, with the GUI
serving as the client and the Google Books API as the server.
 Client (GUI):
o Built using Python's Tkinter library.
o Handles user interactions and displays results.
 Server (Google Books API):
o Processes requests and provides book data.

3.4 Class Diagram

30
3.5 sequence Diagram

31
3.6 Flow chart

32
3.7 Component Design
Input Component:
o Entry box for user to input search keywords.
 Processing Component:
o fetch_book_details() function to query Google Books API.
o apply_filters() function to refine results.
 Output Component:
o Dynamic frames displaying book covers, titles, and metadata.
o Error message popups for invalid API responses.

33
 4.Coding
4.1 Algorithms
1. Initialization
1. Start the program and initialize the GUI components using the
Tkinter library.
2. Set up global variables and data structures:
o inc to track the current book being displayed.
o check_var and check_var2 for filter toggles (Publish Date,
Rating).

2. User Interaction
2.1 Search Input
1. Wait for the user to input a search query in the entry box.
2. On "Search" button click:
o Clear previous results (clear_results function).
o Validate the input.

3. API Integration
1. Construct a request to the Google Books API using the entered
query.
o Encode the query to ensure compatibility with the API.
o URL format: https://www.googleapis.com/books/v1/volumes?
q=<search_query>&maxResults=5.
34
 2. Send a GET request to the API.
3. Check the response:
o If successful (status_code == 200), parse the JSON data.
o If failed, display an error message to the user.

4. Data Processing
1. Iterate through the response data to extract book information:
o Metadata: Title, Author(s), Published Date, Rating.
o Images: Fetch thumbnail URLs.
2. Call fetch_information() for each book:
o Update the GUI with the title, image, publication date, and
rating.
o Use the Pillow library to process and resize images.

5. Display Results
1. Populate the GUI frames with book details:
o Display book covers and metadata in their respective slots.
o If filters are toggled (Publish Date, Rating), update the frames
accordingly.

6. Filters
1. Check the state of filters (check_var and check_var2):

35
 o If enabled, show the Publish Date and/or Rating.
o If disabled, hide the corresponding fields.
2. Re-render the GUI dynamically based on filter changes.

7. Error Handling
1. If no results are found or the API fails:
o Display a friendly error message (e.g., "No results found" or
"Failed to fetch data").
2. Catch exceptions during the API call to prevent crashes.

8. Logout and Exit

1. Provide a "Logout" button to allow the user to exit the application.
2. On click, terminate the GUI window and clean up resources.

9. Repeat
 Wait for further user actions (e.g., new searches, filter updates).
 Repeat the process starting from Step 2.

10. Flow of Algorithm

1. Initialize GUI.

36
 2. Wait for user input.
3. On search:
o Clear old results.
o Fetch new data via API.
o Update the GUI with results.
4. Apply filters if needed.
5. Handle errors gracefully.
6. Exit on user request

4.2 Code Snippets

main.py :
37
from tkinter import *
from tkinter import messagebox
import requests
from PIL import ImageTk, Image
from io import BytesIO
import urllib.parse

class Request:
def __init__(self, method, args):
self.args = args
self.method = method

inc = 0
def fetch_information(title, poster, date, rating):
global inc
inc += 1

text[f'a{inc}'].config(text=title)
if check_var.get():
text2[f'a{inc}{inc}'].config(text=date)
else:
text2[f'a{inc}{inc}'].config(text="")

if check_var2.get():
38
 text3[f'a{inc}{inc}{inc}'].config(text=rating)
else:
text3[f'a{inc}{inc}{inc}'].config(text="")

response = requests.get(poster)
img_data = response.content
img = Image.open(BytesIO(img_data))
resized_image = img.resize((140, 200))
photo2 = ImageTk.PhotoImage(resized_image)
image[f'b{inc}'].config(image=photo2)
image[f'b{inc}'].image = photo2

def clear_results():
global inc
inc = 0
for i in range(1, 6):
text[f'a{i}'].config(text="")
text2[f'a{i}{i}'].config(text="")
text3[f'a{i}{i}{i}'].config(text="")
image[f'b{i}'].config(image="")

def search():
global inc
39
 clear_results() # Clear previous results
request = Request('GET', {'search': Search.get()})

if request.method == 'GET':
search = urllib.parse.quote(request.args.get('search', ''))
url = f"https://www.googleapis.com/books/v1/volumes?
q={search}&maxResults=5"
response = requests.get(url)

if response.status_code == 200:
data = response.json()
for item in data.get('items', []):
volume_info = item.get('volumeInfo', {})
title = volume_info.get('title', 'N/A')
publisher = volume_info.get('publisher', 'N/A')
published_date = volume_info.get('publishedDate', 'N/A')
author = volume_info.get('authors', ['N/A'])
rating = volume_info.get('averageRating', 'N/A')
image_links = volume_info.get('imageLinks', {})
image = image_links.get('thumbnail', 'N/A')

# print(title)
# print(publisher)
# print(published_date)
40
 # print(author)
# print(rating)
# print(image)

fetch_information(title, image, published_date, rating)

# Show frames if any checkbox is selected

if check_var.get() or check_var2.get():
frame11.place(x=160, y=600)
frame22.place(x=360, y=600)
frame33.place(x=560, y=600)
frame44.place(x=760, y=600)
frame55.place(x=960, y=600)
else:
frame11.place_forget()
frame22.place_forget()
frame33.place_forget()
frame44.place_forget()
frame55.place_forget()
else:
print("Failed to fetch data from Google Books API")
messagebox.showinfo("info", "Failed to fetch data from Google
Books API.")

41
def show_menu(event):
# Display the menu at the mouse position
menu.post(event.x_root, event.y_root)

root = Tk()
root.title("Book Recommender System")
root.geometry("1250x700")
root.config(bg="#111119")
root.resizable(False, False)

# Icon
icon_image = PhotoImage(file="Images/icon.png")
root.iconphoto(False, icon_image)

# Background image
heading_image = PhotoImage(file="Images/background.png")
Label(root, image=heading_image, bg="#111119").place(x=-2, y=-2)

# Logo
logo_image = PhotoImage(file="Images/booklogo.png")
Label(root, image=logo_image, bg="#0099ff").place(x=300, y=80)

42
# Heading
heading = Label(root, text="BOOK RECOMMENDATION",
font=("Helvetica", 30, "bold"), fg="white", bg="#0099ff")
heading.place(x=400, y=85)

# Search Background image

search_box = PhotoImage(file="Images/Rectangle 2.png")
Label(root, image=search_box, bg="#0099ff").place(x=300, y=155)

# Entry box / Search section

Search = StringVar()
search_entry = Entry(root, textvariable=Search, width=20, font=("Lato",
25), bg="white", fg="black", bd=0)
search_entry.place(x=415, y=172)

# Search Button
recommend_button_image = PhotoImage(file="Images/Search.png")
recommend_button = Button(root, image=recommend_button_image,
bg="#0099ff", bd=0, activebackground="#252532", cursor="hand2",
command=search)
recommend_button.place(x=860, y=169)

# Setting Button
Setting_image = PhotoImage(file="Images/setting.png")
43
setting = Button(root, image=Setting_image, bd=0, cursor="hand2",
activebackground="#0099ff", bg="#0099ff")
setting.place(x=1050, y=175)
setting.bind('<Button-1>', show_menu)

menu = Menu(root, tearoff=0) # Menu for search button

check_var = BooleanVar()
menu.add_checkbutton(label="Publish Date", variable=check_var,
command=lambda: print(f"Check Option is {'checked' if
check_var.get() else 'unchecked'}"))
check_var2 = BooleanVar()
menu.add_checkbutton(label="Rating", variable=check_var2,
command=lambda: print(f"Rating Check Option is {'checked'
if check_var2.get() else 'unchecked'}"))

# Logout Button
Logout_image = PhotoImage(file="Images/logout.png")
Button(root, image=Logout_image, bg="#0099ff",
cursor="hand1",
command=lambda: root.destroy()).place(x=1150, y=20)

# First Frame
frame1 = Frame(root, width=150, height=240, bg="white")
frame2 = Frame(root, width=150, height=240, bg="white")
frame3 = Frame(root, width=150, height=240, bg="white")
44
frame4 = Frame(root, width=150, height=240, bg="white")
frame5 = Frame(root, width=150, height=240, bg="white")
frame1.place(x=160, y=350)
frame2.place(x=360, y=350)
frame3.place(x=560, y=350)
frame4.place(x=760, y=350)
frame5.place(x=960, y=350)

# Book Title
text = {'a1': Label(frame1, text="Book Title", font=("arial", 10),
fg="green"),
'a2': Label(frame2, text="Book Title", font=("arial", 10), fg="green"),
'a3': Label(frame3, text="Book Title", font=("arial", 10), fg="green"),
'a4': Label(frame4, text="Book Title", font=("arial", 10), fg="green"),
'a5': Label(frame5, text="Book Title", font=("arial", 10), fg="green")}
text['a1'].place(x=10, y=4)
text['a2'].place(x=10, y=4)
text['a3'].place(x=10, y=4)
text['a4'].place(x=10, y=4)
text['a5'].place(x=10, y=4)

# Poster / Image of Book

image = {'b1': Label(frame1),
'b2': Label(frame2),
45
 'b3': Label(frame3),
'b4': Label(frame4),
'b5': Label(frame5)}
image['b1'].place(x=3, y=30)
image['b2'].place(x=3, y=30)
image['b3'].place(x=3, y=30)
image['b4'].place(x=3, y=30)
image['b5'].place(x=3, y=30)

# Second Frame
frame11 = Frame(root, width=150, height=50, bg="#e6e6e6")
frame22 = Frame(root, width=150, height=50, bg="#e6e6e6")
frame33 = Frame(root, width=150, height=50, bg="#e6e6e6")
frame44 = Frame(root, width=150, height=50, bg="#e6e6e6")
frame55 = Frame(root, width=150, height=50, bg="#e6e6e6")
# Date
text2 = {'a11': Label(frame11, text="date", fg="red", font=("arial", 10),
bg="#e6e6e6"),
'a22': Label(frame22, text="date", fg="red", font=("arial", 10),
bg="#e6e6e6"),
'a33': Label(frame33, text="date", fg="red", font=("arial", 10),
bg="#e6e6e6"),
'a44': Label(frame44, text="date", fg="red", font=("arial", 10),
bg="#e6e6e6"),

46
 'a55': Label(frame55, text="date", fg="red", font=("arial", 10),
bg="#e6e6e6")}
text2['a11'].place(x=10, y=4)
text2['a22'].place(x=10, y=4)
text2['a33'].place(x=10, y=4)
text2['a44'].place(x=10, y=4)
text2['a55'].place(x=10, y=4)

# Rating
text3 = {'a111': Label(frame11, text="rating", font=("arial", 10),
bg="#e6e6e6"),
'a222': Label(frame22, text="rating", font=("arial", 10),
bg="#e6e6e6"),
'a333': Label(frame33, text="rating", font=("arial", 10),
bg="#e6e6e6"),
'a444': Label(frame44, text="rating", font=("arial", 10),
bg="#e6e6e6"),
'a555': Label(frame55, text="rating", font=("arial", 10),
bg="#e6e6e6")}
text3['a111'].place(x=20, y=30)
text3['a222'].place(x=20, y=30)
text3['a333'].place(x=20, y=30)
text3['a444'].place(x=20, y=30)
text3['a555'].place(x=20, y=30)
root.mainloop()

47
try.py :
import requests
import urllib.parse

class Request:
def __init__(self, method, args):
self.args = args
self.method = method

request = Request('GET', {'search': "Galvin"})

if request.method == 'GET':
search = urllib.parse.quote(request.args.get('search', ''))
url = f"https://www.googleapis.com/books/v1/volumes?
q={search}&maxResults=1"
response = requests.get(url)

if response.status_code == 200: # 200 means the request was successful

data = response.json()
for item in data.get('items', []):
volume_info = item.get('volumeInfo', {})
title = volume_info.get('title', 'N/A')
publisher = volume_info.get('publisher', 'N/A')
published_date = volume_info.get('publishedDate', 'N/A')
48
 author = volume_info.get('authors', ['N/A'])
rating = volume_info.get('averageRating', 'N/A')
image_link = volume_info.get('imageLinks', {})
image = image_link.get('thumbnail', 'N/A')

print("Title:", title)
print("Publisher:", publisher)
print("Published Date:", published_date)
print("Author(s):", ", ".join(author))
print("Rating:", rating)
print("Image URL:", image)
else:
print(f"Failed to fetch data. Status code: {response.status_code}")

49
 5.testing
The testing phase ensures that the Book Recommendation System is
functional, reliable, and meets the specified requirements. Various
testing methodologies, including unit testing, integration testing, and
user acceptance testing, are used.

5.1 Unit Testing Plan

 Objective: To test individual components or functions in isolation.
 Components Tested:
1. Search Functionality: Verify that user inputs are correctly processed
into API requests.
2. API Integration: Test fetch_book_details() to ensure it successfully
fetches data from the Google Books API.
3. Filter Functions: Test filtering logic for publication dates and ratings.
4. Error Handling: Verify that proper messages are displayed for API
errors or empty results.
5. GUI Components: Test entry fields, buttons, and frames for proper
rendering and responsiveness.

50
5.2 Integration Testing
 Objective: To test the interaction between different components.
 Scenarios:
1. GUI and API: Ensure the search query from the GUI is correctly sent
to the API, and the results are displayed.
2. Dynamic Updates: Verify that search results and filters dynamically
update the GUI without errors.
3. Error Propagation: Test how API errors (e.g., invalid queries or server
failures) propagate to the GUI.

5.3 System Testing

 Objective: To test the system as a whole in a simulated real-world
environment.
 Scenarios:
1. Perform a valid search and verify that the top 5 books are displayed.
2. Apply filters (e.g., ratings, publication dates) and verify filtered
results.
3. Test the system with invalid inputs (e.g., special characters, blank
inputs) to check for proper error handling.

51
5.4 User Acceptance Testing (UAT)
 Objective: To ensure the system meets user expectations and is intuitive.
 Methodology:
1. Select users to perform searches and apply filters.
2. Collect feedback on system usability, response times, and visual
appeal.
3. Verify that users can easily interpret error messages and navigate the
interface.

5.6 Performance Testing

 Response Time: Verify that results are fetched and displayed
within 3-5 seconds after a query is entered.
 Stress Testing: Simulate high usage (e.g., multiple users searching
simultaneously) to ensure the system remains stable.

5.7 Tools Used

 Manual Testing: For GUI responsiveness and user interaction.
 Postman: To test API responses independently.
 Unit Testing Frameworks: Python’s unit-test library for function-
level testing.

52
5.8 Test case
Test
Case Test Case Description Input Expected Output Result
ID

Display top 5
Verify search
TC01 "Harry Potter" results with titles, Pass/Fail
functionality
covers, ratings

Verify API response JSON data

Valid book title
TC02 handling for valid processed and Pass/Fail
query
query displayed

Verify API response

Display "No results
TC03 handling for invalid "!!!###" Pass/Fail
found" message
query

Display filtered
Verify GUI updates
TC04 Ratings > 4.0 results based on Pass/Fail
after applying filters
rating criteria

Display error
Verify handling of API Network
TC05 message: "Failed to Pass/Fail
failure disconnected
fetch data."

GUI handles
Test responsiveness of Click "Search"
TC06 updates without Pass/Fail
GUI multiple times
crashing

Display resized
Verify book image Fetch books with
TC07 images without Pass/Fail
rendering covers
distortion

Test logout Close the

TC08 Click "Logout" Pass/Fail
functionality application

6. IMPLEMENTATION
53
Data Loading and Pre-processing:
The system fetches data from the Google Books API using the search
query provided by the user. The retrieved data is processed and stored in
a JSON format for efficient handling and display.
GUI Development:
The GUI is developed using Python's Tkinter library, providing a user-
friendly interface for searching and displaying book recommendations.
The main window consists of five frames, each displaying details of one
recommended book.
Feature Integration:

1. Search The search function queries the

Functionality: Google Books API and processes
the results.

Display Frames: 2. Each frame displays the book's

cover, title, author, and optional
details such as publication date
and rating.

3. Optional Features: 4. Users can opt to view additional

information about the books.

Link: https://www.googleapis.com/books/v1/volumes?
q={search}&maxResults=5

54
 using Tkinter
Python offers multiple options for developing GUI (Graphical User
Interface). Out of all the GUI methods, tkinter is the most commonly
used methods. It is a standard python interface to the Tk GUI toolkit
shipped with Python. Python with tkinter outputs the fastest and easiest
way to create the GUI applications. Now, it’s up to the imagination or
necessity of developer, what he/she wants to develop using this toolkit.

To create a tkinter:
 Importing the module - tkinter
 Create the main window (container)
 Add any number of widgets to the main window.
 Apply the event Tigger on the main window.

Let’s create a GUI based simple Real-time Weather detection

application which can give Weather details of any cities.
Modules required:
Pillow
Requests

55
 Book Recommendation Application

How to start:
It is a quite easy work with python; in this method we have used
few advance libraries like requests and pillow

How to start in few simple steps:

1. Open Terminal, and install all required modules.
 pip install pillow == 11.0.0
 pip install requests == 2.32.3
Then open python file with the help of IDE, or by double click on
file.

56
It is the first interface of Book Recommendation Application, which is
completely design with the help of python tkinter.
It also contains a Logout button with the help of which we can control
user logout and with setting button we can check author name, rating etc
of book.

Advantages:
 User-Friendly Interface
 Efficient Data Retrieval
 User can choose to display additional information such as
publication dates and ratings, allowing for more tailored
experience.
 System displays book covers and other details in a visually
appealing format, enhacing the user experience.

Disadvantages:
 Dependency on External API
 Limited by API Results
 Data Privacy Concerns
 Scalability Limitations

57
 7. Limitations of Proposed System
Despite its benefits, the proposed system has the following limitations:
1. Dependency on External APIs
 The system relies entirely on the Google Books API for fetching
book data. If the API is unavailable or experiences downtime, the
system cannot function.
 Changes in the API structure or policies (e.g., rate limits or
deprecated endpoints) may require system updates.

2. Limited Personalization
 The system does not provide personalized recommendations based
on user history, preferences, or behavioral data.
 Advanced features like collaborative or content-based filtering are
not implemented.

3. Basic Filtering Options

 The filters are limited to publication dates and ratings, which may
not fully meet user needs, such as genre or language-specific
searches.
 Customizable search preferences (e.g., excluding certain publishers
or authors) are absent.

58
4. Performance Constraints
 The system fetches data for a maximum of five books per search,
which may not satisfy users looking for a broader range of
recommendations.
 Response times depend on the speed of the API and internet
connectivity, which may cause delays.

5. Lack of Offline Functionality

 The system requires an active internet connection to interact with
the API. Offline searches or cached results are not supported.

6. Minimal Visual Customization

 Although visually appealing, the GUI design does not allow users
to customize themes, layouts, or font sizes, potentially limiting
accessibility for certain user groups.

7. No User Authentication
 The system lacks user authentication and account management
features, which could limit personalization and restrict the ability
to save user-specific searches or preferences.

59
8. Limited Scalability
 The current design supports only basic features and is not
optimized for handling large volumes of data or concurrent users.
 Expanding the system to include advanced recommendation
algorithms or integrations may require significant redesign.

9. Error Handling Limitations

 While basic error handling is implemented, it may not cover all
edge cases, such as incomplete or malformed API responses.
 Errors displayed to users are generic and might not provide enough
information for troubleshooting.

10. No Advanced Analytics

 The system does not provide insights such as trending books, user
statistics, or usage patterns, which could enhance user engagement

60
 8. Proposed Enhancements
To improve the functionality, user experience, and scalability of the
system, the following enhancements are proposed:

1. Personalized Recommendations
 Feature: Implement user accounts with personalized preferences.
o Users can save their favorite genres, authors, or previous
searches.
o Recommendations are tailored based on user history.
 Benefit: Enhances user satisfaction by providing more relevant
suggestions.

2. Advanced Search and Filters

 Feature:
o Add advanced filters such as genre, language, and availability
(e.g., free books or paid).
o Allow sorting results by popularity, rating, or publication
year.
 Benefit: Gives users more control over search results, making the
system versatile.

3. Integration with Other APIs

 Feature: Integrate additional APIs like Goodreads or Open Library
for user reviews and extended metadata.
61
  Benefit: Provides richer information and expands the variety of
books.

4. User Reviews and Ratings

 Feature:
o Allow users to rate books directly in the application.
o Display community reviews from platforms like Goodreads.
 Benefit: Improves the system's value by incorporating user-
generated content.

5. Bookmarking and Favourites

 Feature: Add a feature to bookmark books or create a “Favourites”
list.
 Benefit: Enables users to save books for future reference.

6. Enhanced Visual Design

 Feature:
o Improve the GUI with modern design elements (e.g., card-
style layouts, hover effects).
o Include animations for loading results.
 Benefit: Creates a visually engaging user experience.

62
7. Offline Mode
 Feature: Cache previously searched data to enable offline access to
book details.
 Benefit: Improves usability for users with limited internet
connectivity.

8. Multi-Language Support
 Feature: Provide language localization options for the GUI.
 Benefit: Expands the system’s usability to non-English-speaking
users.

9. Mobile and Web Versions

 Feature:
o Develop mobile (iOS and Android) and web versions of the
system.
o Synchronize user accounts across devices.
 Benefit: Increases accessibility and user reach.

63
10. AI-Powered Suggestions
 Feature:
o Use machine learning algorithms to suggest books based on
user preferences and patterns.
o Recommend trending books or similar books based on user
selections.
 Benefit: Elevates the recommendation system's intelligence and
adaptability.

11. Error and Logging System

 Feature:
o Implement robust error tracking and logging for better
debugging.
o Provide detailed error messages to users (e.g., API timeout vs.
invalid input).
 Benefit: Improves system reliability and maintenance.

12. Dark Mode

 Feature: Add a toggle for light and dark themes in the GUI.
 Benefit: Improves usability for users who prefer dark mode.

64
 9. Bibliography
Below is the list of resources and references used for the development,
research, and conceptualization of the Book Recommendation System:

Books and Articles

1. O'Reilly Media
o "Python Programming: Building Robust and Scalable
Systems"
o Insightful guidance on Python development for GUI and API
integration.
2. "Building Recommendation Engines" by Sureshkumar Gorakala
and Micheal Ryaboy
o Provided a foundation for understanding recommendation
system algorithms and user behavior modeling.
3. Research Papers
o "Collaborative Filtering for Book Recommendations"
 Explored advanced recommendation techniques based on
user preferences.
o "Hybrid Recommendation Systems: A Survey"
 Discussed combining content-based and collaborative
filtering.

65
Web Resources
1. Google Books API Documentation
o Official documentation for implementing and using the API
for fetching book data.
o https://developers.google.com/books
2. Tkinter Documentation (Python)
o Resource for GUI development with the Tkinter library.
o https://docs.python.org/3/library/tkinter.html
3. Pillow (PIL Fork) Documentation
o Official guide for image processing and resizing in Python.
o https://pillow.readthedocs.io
4. Stack Overflow
o Community-based solutions for common programming
challenges and debugging.
o https://stackoverflow.com
5. GeeksforGeeks
o Tutorials and code snippets for Tkinter and API integration.
o https://www.geeksforgeeks.org

66
Online Tutorials and Videos
1. YouTube - Python GUI Tutorials
o Tutorials on building GUIs with Tkinter and integrating APIs
in Python.
2. Udemy Course - "Python Programming with APIs"
o Comprehensive course on creating Python applications with
third-party APIs.

Tools Used
1. Postman
o For testing the Google Books API and verifying data
responses.
o https://www.postman.com
2. PLANTUML
o For creating UML diagrams, sequence diagrams, and
flowcharts.
o https://plantuml.com

67
 10. User Manual
This user manual provides a comprehensive guide to using the Book
Recommendation System, including screen descriptions, data
validations, and the purpose of each feature.

1. Home Screen
Description:
 Purpose: Provides the main interface for users to search for books.
 Elements:
o Search Bar: An input field where users can enter the title,
author, or keyword of the book.
o Search Button: Executes the search query and fetches data
from the Google Books API.
o Settings Button: Opens a menu to enable/disable filters for
publication date and rating.
o Logout Button: Allows users to exit the application.
Validations:
 Search Input:
o Must not be empty. If left blank, an error message is
displayed: "Please enter a valid query."
o Special characters or invalid queries (e.g., "!!!###") return a
"No results found" message.

68
User Interaction:
1. Enter a search term (e.g., "Harry Potter") in the search bar.
2. Click the "Search" button to fetch results.
3. Use the Settings menu to apply filters if needed.

2. Results Screen
Description:
 Purpose: Displays the top 5 recommended books based on the
search query.
 Elements:
o Book Cover: Thumbnail image of each book fetched from the
API.
o Book Title: Title of the book displayed below the cover.
o Publication Date (Optional): Displayed only if the "Publish
Date" filter is enabled.
o Rating (Optional): Displayed only if the "Rating" filter is
enabled.
Validations:
 The system ensures that all data (title, cover, date, rating) is fetched
and displayed accurately.
 If any field is unavailable (e.g., no rating), it will display "N/A"
instead.

69
User Interaction:
 View the displayed books and their metadata.
 If filters are applied, the interface updates dynamically to include
or exclude date and rating information.

3. Settings Menu
Description:
 Purpose: Provides options to customize the results display by
enabling/disabling filters.
 Elements:
o Checkbox for Publish Date: Toggles the display of the
book's publication date.
o Checkbox for Rating: Toggles the display of the book's
rating.
Validations:
 The filters are dynamically applied when selected; no additional
input is required.
User Interaction:
1. Click the "Settings" button.
2. Enable/disable the desired filters (e.g., check/uncheck "Publish
Date").
3. View the updated results with the applied filters.

70
4. Error Handling
Description:
 Purpose: Ensures user-friendly error messages for invalid inputs or
system issues.
 Scenarios:
o Invalid Search Query: If the search bar is left empty, the
system displays an alert: "Please enter a valid query."
o API Failure: If the API fails to respond or no results are
found, the system displays: "Failed to fetch data from Google
Books API."
o Network Issues: If there’s no internet connection, the system
alerts the user.

71
Screenshots with Description
1. Home Screen
 Screenshot: Displays the main interface with the search bar,
"Search" button, settings, and logout options.
 Purpose: To initiate a book search.

72
2. Results Screen
 Screenshot: Shows the search results with book covers, titles, and
optional filters (publish date, rating).
 Purpose: To display fetched book data.

73
3. Settings Menu
 Screenshot: Displays checkboxes for enabling/disabling filters.
 Purpose: Allows users to customize the display of results.

74
4. Error Message Popups
 Screenshot: Error popups for invalid queries, no results, or
network issues.
 Purpose: Guides the user in correcting inputs or understanding
system limitations

75
 11. Conclusion
The Book Recommendation System provides a valuable tool for book
enthusiasts to discover new books based on their interests. By
leveraging the Google Books API and presenting data through a user-
friendly Tkinter GUI, the system offers a seamless experience for users
to find and explore books. Future enhancements can further improve the
system's functionality and personalization.

Signature-
Guide: Dr. Poonam Sawant

76