MOVIE WATCH LIST MANAGEMENT

COMPUTER SCIENCE PROJECT

MAGHILLAN L.G
SHARAN KISHNA .L
PRANAV.U
’XI B’
SUNSHINE SSM SENIOR SECONDARY SCHOOL
CHENNAI – 600044
 ACKNOWLEDGEMENT

I would like to express my special thanks of gratitude to our principal Mrs. T V

Revathi and Academician Mrs. Arthi mam for their support to complete our project.

I would like thank our compute science teacher Mrs.Padma Priya.R for giving me

such an opportunity to do this wonderful project on the topic “ICE CREAM SHOP

MANAGEMENT”, which also helped me in doing a lot of research work to get enriched

with knowledge about different programming techniques and learnt to use different

modules and user defined functions . I would like to thank my friends and family

who helped me a lot in completing this project within the limited time period.
 TABLE OF CONTENT

S.NO TOPICS PG.N0

1. ABSRACT

HARDWARE AND SOFTWARE

2. REQUIREMENT

3. FUNCTIONS USED

4. MODULUS

5. SOURCE CODE

6. OUTPUT

7. FUTURE ENCHANTMENS

8. REFERENCES
 OVERVIEW OF PYTHON

Python is a versatile, interpreted, object-oriented, and high-level programming

language known for its dynamic semantics. It boasts built-in data structures,
dynamic typing, and dynamic binding, making it particularly appealing for
Rapid Application Development (RAD) and serving as a scripting or glue
language to connect different components. Its simplicity and easy-to-learn
syntax prioritize readability, reducing the costs associated with program
maintenance. Python supports modules and packages, fostering program
modularity and code reuse. The Python interpreter, along with its extensive
standard library, is freely available for all major platforms, promoting
widespread adoption.

Programmers often appreciate Python for its enhanced productivity due to the
absence of a compilation step, facilitating a rapid edit-test-debug cycle.
Debugging is straightforward, with errors resulting in exceptions rather than
segmentation faults. Python's introspective power is evident in its source-level
debugger, written in Python itself. While the debugger offers in-depth analysis,
the language's simplicity allows for quick debugging through the addition of
print statements.

Python's applications span diverse domains, including website and software

development, task automation, data analysis, and data visualization. Its user-
friendly nature has led to adoption by non-programmers, such as accountants
and scientists, for everyday tasks like financial organization. Python's
multipurpose, object-oriented, and high-level characteristics contribute to its
popularity among coders and developers. Notable features include being free and
open source, easy-to-code, support for GUI programming, a high-level language,
and a large and supportive community. Its portability adds to its appeal, making
Python a go-to language for a wide range of coding and development needs.
 ABSTRACT

In our project, the "Movie Management System," we've developed a

comprehensive Python program that serves as a feature-rich platform for
efficiently managing and organizing a personal movie collection. The application
leverages the Tkinter library to create an intuitive graphical user interface with a
tab-based layout, offering a variety of functionalities to cater to diverse user
needs.

The program begins by providing options to add, remove, and update movie
details, including the title, director, release year, and genre. Each operation is
encapsulated within a dedicated tab, ensuring a clear and organized user
experience. The interface incorporates input fields and buttons for seamless
interaction, promoting user-friendly navigation.

Additionally, the Movie Management System introduces features such as

creating watch lists and marking movies as already watched. Users can add
movies to their watch list, view the contents of the watch list, and transition
movies from the watch list to the already-watched list. These functionalities
cater to the dynamic nature of managing a movie collection, accommodating
both planned and completed viewings.

The system also provides a snapshot of the user's movie collection through tabs
that display the entire collection, added movies, and options to filter movies
based on genre or release year. This ensures that users can easily explore and
analyze their movie preferences within the application.

Underlying the graphical interface is a robust back-end logic that manipulates

Python dictionaries to store and manage movie details. The code demonstrates
proficiency in dictionary operations, event-driven programming, and efficient
GUI design.

Overall, the Movie Management System goes beyond a simple movie database
and encapsulates a holistic approach to movie organization, providing a
practical tool for movie enthusiasts to curate, track, and explore their cinematic
preferences in a user-friendly environment.
 HARDWARE AND SOFWARE REQUIREMENTS

1) HARDWARE REQUIREMENTS:
 A Personal computer with
I. 1MB RAM or above
II. Hard disk space of 128MB

2) SOFTWARE REQUIREMENTS:
1) Operating System:

 Windows:
Windows 10 or higher with 64 bit architecture.
 Mac OS:
Mac OS X or higher with 64 bit architecture.
 Linux:
RHEL 6 or higher with 64 bit architecture.

2) Software Requirements:

Python 3, version 3.9.1 or above.

 INSTALLATION OF PYTHON:
1. Visit www.python.org.
2. Click on the downloads tab and download the latest version of python setup file.
3. After downloading, execute the file and install Python application.
 FUNCTIONS USED
1. __init__(self, root):
Initializes the MovieManagementApp with the main root window, sets up
the movie-related data structures, creates a tabbed interface, and
initializes the Text widget for output.

2. create_widgets(self, frame, index):

Creates widgets for each tab in the tabbed interface based on the given
index. The widgets include labels, entry fields, buttons, and dropdowns,
depending on the functionality of the tab.

3. add_movie(self, title, director, year, genre):

Adds a movie to the `movies` dictionary with the provided title, director,
year, and genre. Also, updates the output in the Text widget.

4. remove_movie(self, title):

Removes a movie with the specified title from the `movies` dictionary and
updates the output in the Text widget.

5. update_movie(self, title, new_title):

Updates the title of a movie with the specified title to a new title and
updates the output in the Text widget.

6. add_to_watch_list(self, title):

Adds a movie with the specified title to the watch list (`watch_list`) and
updates the output in the Text widget.

7. show_watch_list(self):

Displays the movies in the watch list in the output Text widget.

8. add_to_already_watched(self, title):

Adds a movie with the specified title to the already-watched list

(`already_watched`) and removes it from the watch list. Updates the output
in the Text widget.
 9. show_already_watched(self):

Displays the movies in the already-watched list in the output Text widget.

10. show_your_movies(self):

Displays the details of the movies in the `movies` dictionary in the output
Text widget.

11. show_added_movies(self):

Displays the titles of the movies in the `movies` dictionary in the output
Text widget.

12. choose_genre(self, genre):

Displays movies from the `movies` dictionary that match the specified
genre in the output Text widget.

13. choose_year(self, release_year):

Displays movies from the `movies` dictionary that were released in the
specified year in the output Text widget.

MODULUS
1) Tkinter:
Tkinter, an integral Python library, empowers developers with a robust and
user-friendly GUI (Graphical User Interface) toolkit for crafting desktop
applications. Functioning as a binding to the Tk GUI toolkit, Tkinter
facilitates the creation of an array of GUI components such as windows,
dialogs, buttons, menus, and more. Renowned for its simplicity and
versatility, Tkinter stands out as an optimal solution for developing cross-
platform applications, ensuring compatibility across Windows, macOS, and
Linux operating systems. Its seamless integration with Python and the ease
with which developers can design interactive interfaces make Tkinter a
preferred choice, enabling the creation of visually appealing and functional
desktop applications with efficiency and flexibility.
 SOURCE CODE
import tkinter as tk
from tkinter import ttk

class MovieManagementApp:
def __init__(self, root):
self.root = root
self.root.title("Movie Management System")

self.movies = {}
self.watch_list = []
self.already_watched = []

self.tabControl = ttk.Notebook(root)

self.tabs = [
"Add Movie",
"Remove Movie",
"Update Movie",
"Add to Watch List",
"Show Watch List",
"Add to Already Watched",
"Show Already Watched",
"Show Your Movies",
"Show Added Movies",
"Choose a Movie Based on Genre",
"Choose a Movie by Release Year"
]
 self.frames = [ttk.Frame(self.tabControl) for _ in range(len(self.tabs))]

for i, (tab, frame) in enumerate(zip(self.tabs, self.frames)):

self.tabControl.add(frame, text=tab)
self.create_widgets(frame, i)

self.tabControl.pack(expand=1, fill="both")

# Create a Text widget for displaying output

self.output_text = tk.Text(root, height=10, width=50, wrap=tk.WORD)
self.output_text.pack()

def create_widgets(self, frame, index):

if index == 0:
label_title = tk.Label(frame, text="Enter the movie title:")
label_title.pack()
entry_title = tk.Entry(frame)
entry_title.pack()

label_director = tk.Label(frame, text="Enter the director's name:")

label_director.pack()
entry_director = tk.Entry(frame)
entry_director.pack()

label_year = tk.Label(frame, text="Enter the release year:")

label_year.pack()
entry_year = tk.Entry(frame)
entry_year.pack()
 label_genre = tk.Label(frame, text="Enter the genre:")
label_genre.pack()
entry_genre = tk.Entry(frame)
entry_genre.pack()

button_add_movie = tk.Button(frame, text="Add Movie", command=lambda:

self.add_movie(entry_title.get(), entry_director.get(), entry_year.get(),
entry_genre.get()))
button_add_movie.pack()

elif index == 1:
label_remove_title = tk.Label(frame, text="Enter the movie title to remove:")
label_remove_title.pack()
entry_remove_title = tk.Entry(frame)
entry_remove_title.pack()

button_remove_movie = tk.Button(frame, text="Remove Movie",

command=lambda: self.remove_movie(entry_remove_title.get()))
button_remove_movie.pack()

elif index == 2:
label_update_title = tk.Label(frame, text="Enter the movie title to update:")
label_update_title.pack()
entry_update_title = tk.Entry(frame)
entry_update_title.pack()

label_new_title = tk.Label(frame, text="Enter the new movie title:")

label_new_title.pack()
entry_new_title = tk.Entry(frame)
entry_new_title.pack()
 button_update_movie = tk.Button(frame, text="Update Movie",
command=lambda: self.update_movie(entry_update_title.get(), entry_new_title.get()))
button_update_movie.pack()

elif index == 3:
label_add_to_watch = tk.Label(frame, text="Enter the movie title to add to the
watch list:")
label_add_to_watch.pack()
entry_add_to_watch = tk.Entry(frame)
entry_add_to_watch.pack()

button_add_to_watch = tk.Button(frame, text="Add to Watch List",

command=lambda: self.add_to_watch_list(entry_add_to_watch.get()))
button_add_to_watch.pack()

elif index == 4:
button_show_watch_list = tk.Button(frame, text="Show Watch List",
command=self.show_watch_list)
button_show_watch_list.pack()

elif index == 5:
label_add_to_watched = tk.Label(frame, text="Enter the movie title to mark as
already watched:")
label_add_to_watched.pack()
entry_add_to_watched = tk.Entry(frame)
entry_add_to_watched.pack()

button_add_to_watched = tk.Button(frame, text="Add to Already Watched",

command=lambda: self.add_to_already_watched(entry_add_to_watched.get()))
button_add_to_watched.pack()

elif index == 6:
 button_show_already_watched = tk.Button(frame, text="Show Already
Watched", command=self.show_already_watched)
button_show_already_watched.pack()

elif index == 7:
button_show_your_movies = tk.Button(frame, text="Show Your Movies",
command=self.show_your_movies)
button_show_your_movies.pack()

elif index == 8:
button_show_added_movies = tk.Button(frame, text="Show Added Movies",
command=self.show_added_movies)
button_show_added_movies.pack()

elif index == 9:
label_genre_choose = tk.Label(frame, text="Choose a movie based on
genre:")
label_genre_choose.pack()

genre_options = ["Action", "Comedy", "Drama", "Science Fiction", "Other"]

chosen_genre = tk.StringVar(frame)
chosen_genre.set(genre_options[0])
genre_dropdown = tk.OptionMenu(frame, chosen_genre, *genre_options)
genre_dropdown.pack()

button_choose_genre = tk.Button(frame, text="Choose Genre",

command=lambda: self.choose_genre(chosen_genre.get()))
button_choose_genre.pack()

elif index == 10:

label_year_choose = tk.Label(frame, text="Choose a movie by release year:")
label_year_choose.pack()
 entry_release_year = tk.Entry(frame)
entry_release_year.pack()

button_choose_year = tk.Button(frame, text="Choose Year",

command=lambda: self.choose_year(entry_release_year.get()))
button_choose_year.pack()

def add_movie(self, title, director, year, genre):

self.movies[title] = {
"Director": director,
"Year": year,
"Genre": genre
}
self.output_text.insert(tk.END, f"{title} has been added to the movie list.\n")

def remove_movie(self, title):

if title in self.movies:
del self.movies[title]
self.output_text.insert(tk.END, f"{title} has been removed from the movie
list.\n")
else:
self.output_text.insert(tk.END, f"{title} is not found in the movie list.\n")

def update_movie(self, title, new_title):

if title in self.movies:
self.movies[new_title] = self.movies.pop(title)
self.output_text.insert(tk.END, f"{title} has been updated to {new_title}.\n")
else:
self.output_text.insert(tk.END, f"{title} is not found in the movie list.\n")
 def add_to_watch_list(self, title):
if title in self.movies and title not in self.watch_list:
self.watch_list.append(title)
self.output_text.insert(tk.END, f"{title} has been added to the watch list.\n")
elif title in self.watch_list:
self.output_text.insert(tk.END, f"{title} is already in the watch list.\n")
else:
self.output_text.insert(tk.END, f"{title} is not found in the movie list.\n")

def show_watch_list(self):
self.output_text.insert(tk.END, "\nWatch List:\n")
for title in self.watch_list:
self.output_text.insert(tk.END, f"{title}\n")

def add_to_already_watched(self, title):

if title in self.movies and title not in self.already_watched:
self.already_watched.append(title)
if title in self.watch_list:
self.watch_list.remove(title)
self.output_text.insert(tk.END, f"{title} has been marked as already
watched.\n")
elif title in self.already_watched:
self.output_text.insert(tk.END, f"{title} is already marked as already
watched.\n")
else:
self.output_text.insert(tk.END, f"{title} is not found in the movie list.\n")

def show_already_watched(self):
self.output_text.insert(tk.END, "\nAlready Watched List:\n")
for title in self.already_watched:
self.output_text.insert(tk.END, f"{title}\n")
 def show_your_movies(self):
self.output_text.insert(tk.END, "\nYour List of Movies:\n")
for title, info in self.movies.items():
self.output_text.insert(tk.END, f"Title: {title}\n")
self.output_text.insert(tk.END, f"Director: {info['Director']}\n")
self.output_text.insert(tk.END, f"Year: {info['Year']}\n")
self.output_text.insert(tk.END, f"Genre: {info['Genre']}\n\n")

def show_added_movies(self):
self.output_text.insert(tk.END, "\nMovies that have been added:\n")
for title in self.movies.keys():
self.output_text.insert(tk.END, f"{title}\n")

def choose_genre(self, genre):

genre_movies = [title for title, info in self.movies.items() if info['Genre'] == genre]
if genre_movies:
self.output_text.insert(tk.END, f"\nMovies in the {genre} genre:\n")
for title in genre_movies:
self.output_text.insert(tk.END, f"{title}\n")
else:
self.output_text.insert(tk.END, f"No movies found in the {genre} genre.\n")

def choose_year(self, release_year):

year_movies = [title for title, info in self.movies.items() if info['Year'] ==
release_year]
if year_movies:
self.output_text.insert(tk.END, f"\nMovies released in {release_year}:\n")
for title in year_movies:
self.output_text.insert(tk.END, f"{title}\n")
else:
 self.output_text.insert(tk.END, f"No movies found released in
{release_year}.\n")

if __name__ == "__main__":
root = tk.Tk()
app = MovieManagementApp(root)
root.mainloop()
 OUTPUT
ADD MOVIE:

REMOVE MOVIE:

UPDATE MOVIE:
ADD TO WATCH LIST:

SHOW WATCH LIST:

ADD TO ALREADY WATCHED:

SHOW ALREADY WATCHED:

SHOW YOUR MOVIES:

SHOW ADDED MOVIES:

CHOOSE A MOVIE BASED ON GENRE:

CHOOSE A MOVIE BY RELEASE YEAR:

 FUTURE ENCHANTMENTS
To enhance the functionality and organization of my movie management system, a key
initiative is the implementation of distinct interfaces tailored for both users and
administrators. The administrator interface will stand as a robust internal management
tool, empowering administrators to effortlessly update, delete, and add movies to our
database. This capability is vital for maintaining a dynamic and accurate movie list,
ensuring efficient control over our inventory, and fostering a well-organized internal
management process.

Simultaneously, the user interface will prioritize delivering a seamless and intuitive
experience for our movie enthusiasts. This user-centric interface aims to facilitate easy
browsing of the movie list, providing straightforward options for adding movies to personal
watch lists, and offering features for marking movies as already watched. By focusing on
user experience, we strive to create an interface that aligns with the preferences and
expectations of our audience, promoting accessibility and user satisfaction.Through the
incorporation of these separate interfaces, the overarching objective is to achieve a
harmonious balance between robust internal management tools for administrators and an
engaging, user-friendly experience for movie enthusiasts. This dual-faceted approach seeks
to elevate both the operational efficiency of the movie management system and the overall
satisfaction of our valued u
 REFERENCES
WEBSITES:

 https://www.python.org/
 https://en.wikipedia.org/wiki/Python_(programming_language).
 https://www.geeksforgeeks.org/python-programming-language/

BOOKS:

 TITLE OF THE BOOK: COMPUTER SCIENCE-TEXTBOOK FOR CLASS XI

VIDEOS:

 https://www.youtube.com/playlist?list=PLCC34OHNcOtoC6GglhF3ncJ5

rLwQrLGnV
sers.