page|1

1. INTRODUCTION
Our project is entitled as Scriby Scoop.
Introducing our innovative educational app designed to make learning engaging and
interactive! Tailored for students of all ages, the app offers a diverse array of options, from
focus timer and timetable maker to vocabulary practice and mindmap generator.

In today's fast-paced educational environment, students and educators alike are constantly
seeking innovative tools to enhance the learning experience. As technology evolves, so too
does the need for comprehensive applications that cater to various educational needs. This
document presents an introduction to an advanced educational application developed in
Python, designed to streamline study practices and foster effective learning through a suite of
integrated features: Notepad, Journal, Timetable Maker, Mind Map Generator, Vocabulary
Practice, and To-Do List. Our app aims to create a holistic platform that promotes efficient
organization, effective study habits, and enhanced knowledge retention.

The application primarily targets students at various educational levels, educators, and
lifelong learners who wish to optimize their learning strategies. By integrating multiple
functionalities, the application serves as a versatile companion for anyone seeking to improve
their academic performance or expand their knowledge.

The Notepad feature offers users a simple yet powerful interface for taking notes. Users can
jot down ideas, lecture summaries, or important information without the distraction of
complicated formatting tools. The flexibility of the Notepad allows for quick access and
seamless editing, ensuring that users can efficiently capture thoughts and ideas as they arise.
Additionally, by supporting rich text formatting options, users can organize their notes with
headings, bullet points, and highlights, enhancing readability and study efficiency.

The Journal feature provides a reflective space for users to document their learning journey
and personal growth. By encouraging daily or weekly entries, the Journal helps users develop
self-awareness and critical thinking skills. This feature not only serves as a record of
academic progress but also supports emotional well-being by allowing users to articulate their
thoughts and feelings. With prompts to guide writing, users of all ages can cultivate a
consistent journaling habit that fosters mindfulness and personal development.
Visual learning enhances comprehension and retention, and the Mind Map Generator caters
to this need by allowing users to create dynamic visual representations of concepts and ideas.
This feature promotes brainstorming and idea organization, enabling students to explore
relationships between different topics. Users can customize their mind maps with colors,
 page|2

images, and links to additional resources, making complex information more accessible and
easier to remember. The collaborative aspect of this tool also fosters teamwork, as users can
share their mind maps for group projects or study sessions.

Vocabulary acquisition is fundamental to language mastery, and our app includes an

engaging Vocabulary Practice feature designed to help users expand their lexicon effectively.
Utilizing interactive quizzes, flashcards, and contextual exercises, this feature adapts to each
user’s proficiency level, ensuring both challenging and attainable learning objectives. By
incorporating gamification elements, such as rewards for progress, users are motivated to
practice regularly, solidifying their understanding of new words and their usage.

To stay organized, users can utilize the To-Do List feature to manage tasks effectively. This
user-friendly tool enables individuals to outline academic responsibilities, assignments, and
personal goals in a prioritized manner. The adjustable interface allows users to assign
deadlines, categorize tasks, and check off completed items, providing a satisfying sense of
achievement. By promoting accountability and organization, the To-Do List supports users in
managing their workload and maintaining focus on their priorities.

Developed using Python, the application leverages robust libraries and frameworks to ensure
functional versatility and a smooth user experience. The choice of Python allows for easy
integration of various features, as well as future scalability. With a focus on accessibility, the
app is designed to function seamlessly across devices, including desktops, tablets, and
smartphones. This cross-platform capability ensures that users can engage with their
educational tools anytime, anywhere.

User experience (UX) is at the forefront of our design philosophy. The app interfaces are
intuitively crafted to foster ease of navigation and engagement. Each feature is equipped with
onboarding tutorials and tooltips to guide new users through its functionalities. Feedback
mechanisms are incorporated to gather user insights for continuous improvement, ensuring
that the app remains responsive to evolving educational needs.
 page|3

2.Objective and scope of the project

The purpose of the "Scribby Scoop" project is to develop a comprehensive educational app
that provides a suite of tools and features to support students in their academic and personal
productivity across the world. The app aims to empower students with a centralized platform
that caters to their diverse needs, from managing their schedules and tasks to enhancing their
learning and self-reflection.
The main objectives of the "Scribby Scoop" project are as follows:
Timetable Maker:
Develop a user-friendly timetable maker that allows students to create and manage their class
schedules, including the ability to input class times, locations, and other relevant
information.Provide features for students to set reminders and notifications for their
upcoming classes and events.Ensure the timetable maker is adaptable to different academic
systems and calendars across various regions.
2. Focus Timer:
Implement a focus timer feature that helps students maintain concentration and productivity
during study or work sessions.Offer customizable timer settings, including the ability to set
work and break intervals, as well as background music or sounds to create a focused
environment.Integrate the focus timer with other app features, such as the to-do list, to
seamlessly track and manage tasks.
3. To-Do List:
Develop a comprehensive to-do list feature that allows students to create, organize, and
prioritize their tasks and assignments .Include options for setting due dates, adding notes, and
marking tasks as complete .Provide the ability to group tasks into categories or projects for
better organization.
4. Notepad:
Incorporate a digital notepad feature that enables students to take handwritten or typed notes
during lectures, meetings, or brainstorming sessions. Offer various formatting options, such
as different pen styles, colors, and the ability to insert images or diagrams. Ensure smooth
integration with other app features, allowing users to easily access and reference their notes.
5. Mind Map Generator:
Implement a mind map generator that empowers students to visually organize their thoughts,
ideas, and concepts. Provide a user-friendly interface for creating, customizing, and sharing
mind maps. Integrate the mind map generator with the notepad feature, allowing users to
seamlessly transition between note-taking and mind mapping.
 page|4

6. Journal:
Develop a journal feature that encourages students to reflect on their daily experiences,
thoughts, and emotions. Offer options for private and secure journaling, with the ability to set
password protection or encryption. Integrate the journal with other app features, such as the
focus timer or timetable, to provide context and enhance self-reflection.
7. Vocabulary Practice:
Incorporate a vocabulary practice module that helps students improve their language skills
and expand their vocabulary. Provide features for creating customizable vocabulary lists,
including the ability to add definitions, sample sentences, and audio pronunciations.
Implement spaced repetition algorithms and gamification elements to make vocabulary
practice engaging and effective.

The "Scribby Scoop" app is designed for students across the world, from primary to tertiary
education levels, who seek a comprehensive and integrated digital tool to enhance their
academic and personal productivity:

 Requirement gathering and analysis

 User interface design and prototyping

 Development of individual app features (timetable maker, focus timer, to-do list,
notepad, mind map generator, journal, vocabulary practice)

 Integration of app features and testing

 Deployment and release of the "Scribby Scoop" app

 Ongoing maintenance, updates, and feature enhancements

 page|5

3.SYSTEM IMPLEMENTATION :

4.1 HARDWARE REQUIREMENTS:

 OPERATING SYSTEM - Windows 7 and above

 PROCESSOR - x86 64-bit CPU (Intel / AMD architecture)

 RAM - 4 GB and above

 HARD DISK - 2 GB of free space

4.2 SOFTWARE REQUIREMENTS:

 Python 3 and above.

 MySQL version 6 and above

 Suitable Operating System

 VS Studio
 page|6

4.SOFTWARE DESCRIPTION:

i) PYTHON:

Python is a high-level, interpreted programming language that has become a staple in the

world of computer science and data analysis. Its simplicity, flexibility, and extensive libraries

make it an ideal language for beginners and experienced programmers alike.

One of the primary reasons Python has gained popularity in recent years is its versatility. It

can be used for a wide range of applications, including web development, scientific

computing, data analysis, artificial intelligence, and more. Additionally, Python's syntax is

designed to be easy to read and write, making it an excellent language for beginners.

In the field of education, Python is often taught as a first programming language due to its

simplicity and forgiving nature. It is widely used in introductory programming courses and has

become a popular choice for teaching programming concepts to students of all ages. Many

educational institutions and online platforms offer Python courses and resources, making it

easily accessible to anyone interested in learning to program.

Furthermore, Python has a vast and active community, with numerous libraries and

frameworks that make it easy to perform various tasks. For instance, NumPy and Pandas are

popular libraries used for data analysis and scientific computing, while Flask and Django are
 page|7

widely used for web development. This extensive ecosystem of libraries and frameworks

makes Python an ideal language for a wide range of applications.

ii) MYSQL:

MySQL is a popular open-source Relational Database Management System (RDBMS)

that enables efficient storage, retrieval, and management of data in a structured format. Its

widespread adoption can be attributed to its ease of use, high performance, and scalability.

One of the key benefits of MySQL is its ability to support a wide range of data types,

including numeric, string, date, and time. This flexibility makes it an ideal choice for various

applications, from simple web-based projects to complex enterprise systems.

MySQL also supports SQL (Structured Query Language), a standard language for managing

relational databases. This allows developers to perform various operations, such as creating

and modifying database structures, inserting and updating data, and querying the database to

retrieve specific information.

In addition to its core features, MySQL offers several advanced functionalities, including

support for stored procedures, views, and triggers. These features enable developers to create

complex logic and automate various tasks, resulting in improved application performance and

reduced development time.

Overall, MySQL is a powerful and versatile database management system that has become an

essential tool in the development of modern web applications. Its ease of use, high
 page|8

performance, and scalability make it an ideal choice for both beginners and experienced

developers alike.

iii) VS STUDIO:

Visual Studio (VS) is an integrated development environment (IDE) from Microsoft,

designed to offer a comprehensive suite of tools for application development. It supports

multiple programming languages, including C, Visual Basic, C++, F#, and Python, making it

suitable for various projects ranging from desktop to web and mobile applications. The IDE

includes advanced features such as IntelliSense for code completion, support for cloud and

mobile development, and integration with version control systems like Git. Additionally, the

latest versions leverage AI for enhanced development support.

 page|9

5.MODULES:

 Tkinter
 Os
 Subprocess
 Colorama
 Threading
 Time
 Datetime
 Matplotlib
 Numpy
 Pyfiglet
 Pil

Sub Modules:
1. tkinter:
 messagebox
 simpledialog
 scrolledtext
 StringVar
 PhotoImage
 Colorchooser
 Scrolledtext
2. PIL:
 Image
 ImageTK

3. colorama:
 Fore

4. datetime:
 timedelta
 p a g e | 10

6.SYSTEM DESIGN AND DEVELOPMENT

6.1.TABLE DESIGN:
 p a g e | 11

6.2. CODING:

importthreading
importsubprocess

defrun_script(script_name):
subprocess.run(["python", script_name])
i=1
whilei==1:
script1_thread=threading.Thread(target=run_script, args=(r"c:\Users\MY-
PC\Downloads\Yalini anand\yalini project\final_project.py",))

script2_thread=threading.Thread(target=run_script, args=(r"c:\Users\MY-
PC\Downloads\Yalini anand\yalini project\background_music_player.py",))

script1_thread.start()
script2_thread.start()

script1_thread.join()
script2_thread.join()

i-=1
 p a g e | 12

importos
importrandom
importpygame

pygame.mixer.init()

music_folder=r'C:\Users\USER\OneDrive\python work\_music_'

music_files= [fforfinos.listdir(music_folder) iff.endswith(('.mp3', '.wav'))]

ifmusic_files:
whileTrue:
song=random.choice(music_files)
pygame.mixer.music.load(os.path.join(music_folder, song))
pygame.mixer.music.play()

whilepygame.mixer.music.get_busy():
pygame.time.Clock().tick(10)
 p a g e | 13

fromtkinterimport*
importtkinterastk
importos
importrandom
fromcoloramaimportFore
fromtkinterimportmessagebox, simpledialog,
scrolledtext,StringVar,PhotoImage,colorchooser,scrolledtext
importtime
importthreading
fromdatetimeimportdatetime, timedelta
importmatplotlib.pyplotasplt
importnumpyasnp
importpyfiglet
fromPILimportImage, ImageTk
importmysql.connectorasmy

text=pyfiglet.figlet_format('Welcome to Scriby
Scoop',font='isometric2',width=100)
print(Fore.RED+text)

name=input(('Enter your name:'))

age=int(input('Age:'))
mobile_no=int(input('Mobile number:'))
conn=my.connect(host='localhost',user='root',passwd='Tvmd@123',datab
ase='yalini_anand')
cur=conn.cursor()
cur.execute('Insert into register (name,age,mobile_no)
values({},{},{})'.format(name,age,mobile_no))
conn.commit()
print('/n/n/n')
 p a g e | 14

defto_do_list():
classTodoApp:
def__init__(self, master):
self.master=master
master.title("To Do List App")

self.bg_image=Image.open(r"c:\Users\MY-PC\Downloads\Yalini
anand\yalini project\to do try.jpg")
self.bg_image=self.bg_image.resize((400, 400))
self.bg_photo=ImageTk.PhotoImage(self.bg_image)

self.canvas=tk.Canvas(master, width=800, height=800)

self.canvas.pack(fill="both", expand=True)
self.canvas.create_image(0, 0, image=self.bg_photo,
anchor="nw")

self.tasks=self.load_tasks()

self.task_input=StringVar()

self.task_entry=tk.Entry(master,
textvariable=self.task_input)
self.task_entry.place(x=20, y=20, width=280)

self.add_task_button=tk.Button(master, text="Add Task",

command=self.add_task)
self.add_task_button.place(x=310, y=20)

self.task_listbox=Listbox(master, selectmode=tk.SINGLE)
self.task_listbox.place(x=20, y=60, width=300, height=300)
 p a g e | 15

self.scrollbar=Scrollbar(master, orient="vertical",
command=self.task_listbox.yview)
self.scrollbar.place(x=320, y=60, height=300)
self.task_listbox.config(yscrollcommand=self.scrollbar.set)

self.delete_task_button=tk.Button(master, text="Delete
Task", command=self.delete_task)
self.delete_task_button.place(x=310, y=365)

self.update_task_listbox()

defadd_task(self):
task=self.task_input.get()
iftask:
self.tasks.append(task)
self.update_tasks_file()
self.update_task_listbox()
self.task_input.set('')
else:
messagebox.showwarning("Warning", "You must enter a
task.")

defdelete_task(self):
try:
selected_task_index=self.task_listbox.curselection()[0]
deleted_task=self.tasks.pop(selected_task_index)
self.update_tasks_file()
self.update_task_listbox()
exceptIndexError:
messagebox.showwarning("Warning", "You must select a
task to delete.")

defupdate_task_listbox(self):
self.task_listbox.delete(0, tk.END)
fortaskinself.tasks:
self.task_listbox.insert(tk.END, task)
 p a g e | 16

defload_tasks(self):
try:
withopen("tasks.txt", "r") asfile:
tasks=file.read().splitlines()
returntasks
exceptFileNotFoundError:
return []

defupdate_tasks_file(self):
withopen("tasks.txt", "w") asfile:
file.write("\n".join(self.tasks))

if__name__=="__main__":
root=tk.Tk()
app=TodoApp(root)
root.geometry("400x400")
root.mainloop()
main_menu()

defnote_taking():
classNoteTakingApp:
def__init__(self, master):
self.master=master
self.master.title("Note Taking App")

self.text_area=scrolledtext.ScrolledText(self.master,
wrap=tk.WORD, width=100, height=20)
self.text_area.pack(pady=50)

self.menu_bar=tk.Menu(self.master)
self.master.config(menu=self.menu_bar)

self.file_menu=tk.Menu(self.menu_bar, tearoff=0)
 p a g e | 17

self.menu_bar.add_cascade(label="File",
menu=self.file_menu)
self.file_menu.add_command(label="New Note",
command=self.new_note)
self.file_menu.add_command(label="Save Note",
command=self.save_note)
self.file_menu.add_command(label="Load Note",
command=self.load_note)
self.file_menu.add_separator()
self.file_menu.add_command(label="Exit",
command=self.master.quit)

self.edit_menu=tk.Menu(self.menu_bar, tearoff=0)
self.menu_bar.add_cascade(label="Edit",
menu=self.edit_menu)
self.edit_menu.add_command(label="Clear",
command=self.clear_text)

defnew_note(self):
self.text_area.delete(1.0, tk.END)

defsave_note(self):
note_content=self.text_area.get(1.0, tk.END)
ifnote_content.strip():
file_name=simpledialog.askstring("Save Note", "Enter
file name:")
iffile_name:
withopen(file_name+".txt", 'w') asf:
f.write(note_content)
messagebox.showinfo("Success", "Note saved
successfully!")
else:
messagebox.showerror("Error", "Cannot save an empty
note!")

defload_note(self):
file_name=simpledialog.askstring("Load Note", "Enter file
name to load:")
iffile_name:
 p a g e | 18

try:
withopen(file_name+".txt", 'r') asf:
note_content=f.read()
self.text_area.delete(1.0, tk.END)
self.text_area.insert(tk.INSERT, note_content)
exceptFileNotFoundError:
messagebox.showerror("Error", "File not found!")

defclear_text(self):
self.text_area.delete(1.0, tk.END)

if__name__=="__main__":
root=tk.Tk()
app=NoteTakingApp(root)
root.mainloop()
main_menu()

defvocabulary_practice():

classLanguageLearningApp:

def__init__(self):

self.vocabulary= {}
self.progress= {}

defadd_word(self, word, translation):

self.vocabulary[word] =translation
self.progress[word] =0
print(f"Added word: {word} - {translation}")
 p a g e | 19

defpractice(self):

ifnotself.vocabulary:

print("No words to practice. Add some words first!")

print('\n\n')
return

word=random.choice(list(self.vocabulary.keys()))
translation=self.vocabulary[word]

print(f"Translate the word: {word}")

user_translation=input("Your translation: ")
print('\n\n')

ifuser_translation.lower() ==translation.lower():

print("Correct!")
print('\n\n')
self.progress[word] +=1

else:

print(f"Incorrect! The correct translation is:

{translation}")
print('\n\n')

defshow_progress(self):

ifnotself.progress:

print("No progress to show. Add and practice words

first!")

print('\n\n')
return

print("Progress:")
print('\n\n')
 p a g e | 20

forword, scoreinself.progress.items():

print(f"{word}: {score} correct answers")

print('\n\n')

defmain():

app=LanguageLearningApp()

whileTrue:
print("\n\nLanguage Learning App\n\n")
print("1. Add a new word\n")
print("2. Practice vocabulary\n")
print("3. Show progress\n")
print("4. Exit\n\n")

choice=input("Choose an option: ")

print('\n\n')

ifchoice=='1':
word=input("Enter the word: ")
print('\n\n')

translation=input("Enter the translation: ")

print('\n\n')

app.add_word(word, translation)
elifchoice=='2':
app.practice()
elifchoice=='3':
app.show_progress()
elifchoice=='4':
print("Exiting the app. Goodbye!")

print('\n\n')
main_menu()
else:
 p a g e | 21

print("Invalid choice. Please try again.")

print('\n\n')

if__name__=="__main__":
main()

deffocus_timer():
classFocusEnhancerApp:
def__init__(self, master):
self.master=master
master.title("Focus Enhancer")

self.timer_label=tk.Label(master, text="Time Remaining:",

font=("Helvetica", 14))
self.timer_label.pack()

self.time_var=tk.StringVar()
self.time_var.set("00:00")
self.remaining_time_label=tk.Label(master,
textvariable=self.time_var, font=("Helvetica", 48))
self.remaining_time_label.pack()

self.start_button=tk.Button(master, text="Start Focus

Timer", command=self.start_timer)
self.start_button.pack()

self.reset_button=tk.Button(master, text="Reset Timer",

command=self.reset_timer)
self.reset_button.pack()
 p a g e | 22

self.focus_duration=25
self.timer_running=False

defstart_timer(self):
ifnotself.timer_running:
self.timer_running=True
self.end_time=datetime.now()
+timedelta(minutes=self.focus_duration)
threading.Thread(target=self.run_timer).start()

defrun_timer(self):
whileself.timer_runninganddatetime.now() <self.end_time:
remaining_time=self.end_time-datetime.now()
minutes,
seconds=divmod(int(remaining_time.total_seconds()), 60)
self.time_var.set(f"{minutes:02}:{seconds:02}")
time.sleep(1)
self.timer_running=False
self.time_var.set("00:00")
self.show_alert()

defreset_timer(self):
self.timer_running=False
self.time_var.set("00:00")

defshow_alert(self):
alert_window=tk.Toplevel(self.master)
alert_window.title("Time's Up!")
alert_message=tk.Label(alert_window, text="Focus time is
over! Time to take a break!", font=("Helvetica", 12))
alert_message.pack()
ok_button=tk.Button(alert_window, text="OK",
command=alert_window.destroy)
ok_button.pack()

if__name__=="__main__":
root=tk.Tk()
app=FocusEnhancerApp(root)
root.mainloop()
 p a g e | 23

main_menu()

deftime_table():
classTimeTableApp:
def__init__(self, root):
self.root=root
self.root.title("Time Table Maker")
self.root.geometry("700x1000")

self.bg_image=PhotoImage(file=r"c:\Users\MY-
PC\Downloads\Yalini anand\yalini project\cat-8762411_1280.png")
self.bg_label=tk.Label(root, image=self.bg_image)
self.bg_label.place(relwidth=1, relheight=1)

self.days= ["Monday", "Tuesday", "Wednesday", "Thursday",

"Friday"]
self.subjects= {day: StringVar() fordayinself.days}

self.create_widgets()

defcreate_widgets(self):
title_label=tk.Label(self.root, text="Time Table Maker",
font=("Helvetica", 24), bg="lightblue")
title_label.pack(pady=20)

fordayinself.days:
frame=tk.Frame(self.root, bg="lightyellow")
frame.pack(pady=5)

day_label=tk.Label(frame, text=day, font=("Helvetica",

18), bg="lightyellow")
day_label.pack(side=tk.LEFT, padx=10)
 p a g e | 24

subject_entry=tk.Entry(frame,
textvariable=self.subjects[day], font=("Helvetica", 14))
subject_entry.pack(side=tk.LEFT, padx=10)

save_button=tk.Button(self.root, text="Save Time Table",

command=self.save_timetable, font=("Helvetica", 16),
bg="lightgreen")
save_button.pack(pady=20)

defsave_timetable(self):
timetable= {day: self.subjects[day].get() fordayinself.days}
withopen("timetable.txt", "w") asfile:
forday, subjectintimetable.items():
file.write(f"{day}: {subject}\n")
messagebox.showinfo("Success", "Time Table saved
successfully!")

if__name__=="__main__":
root=tk.Tk()
app=TimeTableApp(root)
root.mainloop()
main_menu()

defjournal():

classJournalApp:
def__init__(self, root):
self.root=root
self.root.title("Journal App")

self.bg_image=Image.open(r"c:\Users\MY-PC\Downloads\Yalini
anand\yalini project\journal background.jpg")
self.bg_image=self.bg_image.resize((800, 600))
 p a g e | 25

self.bg_photo=ImageTk.PhotoImage(self.bg_image)

self.background_label=tk.Label(root, image=self.bg_photo)
self.background_label.place(x=0, y=0, relwidth=1,
relheight=1)

self.text_area=scrolledtext.ScrolledText(root, wrap=tk.WORD,
font=("Arial", 16),bg="#f7f5d2")
self.text_area.place(relwidth=0.9, relheight=0.8, relx=0.05,
rely=0.1)

self.save_button=tk.Button(root, text="Save Entry",

command=self.save_entry, font=("Arial", 14))
self.save_button.place(relx=0.4, rely=0.9, anchor='center')

defsave_entry(self):
withopen("journal_entries.txt", "a") asfile:
file.write(self.text_area.get("1.0", tk.END) +"\n\n")
self.text_area.delete("1.0", tk.END)

if__name__=="__main__":
root=tk.Tk()
app=JournalApp(root)
root.geometry("800x600")
root.mainloop()
main_menu()

defmind_map_generator():

classMindMapApp:
def__init__(self, master):
self.master=master
 p a g e | 26

self.master.title("Mind Map Generator")

self.central_idea=""
self.branches= []
self.colors= []

self.setup_ui()

defsetup_ui(self):

tk.Label(self.master, text="Enter Central Idea:").pack()

self.central_entry=tk.Entry(self.master)
self.central_entry.pack()

self.add_branch_button=tk.Button(self.master, text="Add
Branch", command=self.add_branch)
self.add_branch_button.pack()

self.generate_button=tk.Button(self.master, text="Generate
Mind Map", command=self.generate_mind_map)
self.generate_button.pack()

self.save_button=tk.Button(self.master, text="Save Mind

Map", command=self.save_mind_map)
self.save_button.pack()

defadd_branch(self):
branch=simpledialog.askstring("Input", "Enter Branch Idea:")
ifbranch:
color=colorchooser.askcolor()[1]
ifcolor:
self.branches.append(branch)
self.colors.append(color)

defgenerate_mind_map(self):
self.central_idea=self.central_entry.get()
 p a g e | 27

ifnotself.central_idea:
messagebox.showwarning("Input Error", "Please enter a
central idea.")
return

self.plot_mind_map()

defplot_mind_map(self):
plt.figure(figsize=(10, 8))
plt.title("Mind Map", fontsize=20)

plt.text(0.5, 0.9, self.central_idea, ha='center',

fontsize=16, bbox=dict(facecolor='lightblue', alpha=0.5))

num_branches=len(self.branches)
fori, (branch, color) inenumerate(zip(self.branches,
self.colors)):
angle= (i/num_branches) *2*np.pi
x=0.5+0.3*np.cos(angle)
y=0.9-0.3*np.sin(angle)
plt.text(x, y, branch, ha='center', fontsize=12,
color=color,
bbox=dict(facecolor=color, alpha=0.5,
edgecolor='black'))

plt.axis('off')
plt.show()

defsave_mind_map(self):
ifnotself.central_idea:
messagebox.showwarning("Input Error", "Please generate a
mind map first.")
return

plt.figure(figsize=(10, 8))
plt.title("Mind Map", fontsize=20)
 p a g e | 28

plt.text(0.5, 0.9, self.central_idea, ha='center',

fontsize=16, bbox=dict(facecolor='lightblue', alpha=0.5))

num_branches=len(self.branches)
fori, (branch, color) inenumerate(zip(self.branches,
self.colors)):
angle= (i/num_branches) *2*np.pi
x=0.5+0.3*np.cos(angle)
y=0.9-0.3*np.sin(angle)
plt.text(x, y, branch, ha='center', fontsize=12,
color=color,
bbox=dict(facecolor=color, alpha=0.5,
edgecolor='black'))

plt.axis('off')
plt.savefig('mind_map.png')
plt.close()
messagebox.showinfo("Saved", "Mind map saved as
'mind_map.png'.")

if__name__=="__main__":
root=tk.Tk()
app=MindMapApp(root)
root.mainloop()
main_menu()

defmain_menu():

print('Hi ',name)

print('************************************************************
*****')
 p a g e | 29

print('\n\n1. Make a To do list \U0001F5D2\n\n2. Take a note

\U0001F4D2\n\n3. Vocabulary Practice \U0001FA90\n\n4. Make a Journal
\U0001F4D2\n\n5. Mind map Generator \U0001F9E0\n\n6. Focus
Enhancer\U0001F551\n\n7. Create a Time Table\U0001F4C6\n\n8.
Exit\n\n')

print('*************************************************************
****')

ch=int(input('Enter Your choice\U0001F446:'))

ifch==1:
to_do_list()

elifch==2:
note_taking()

elifch==3:
vocabulary_practice()

elifch==6:
focus_timer()

elifch==5:
mind_map_generator()

elifch==4:
journal()

elifch==7:
time_table()

elifch>8:
print('The given input is not valid . Try again')

else:
pass

main_menu()
 p a g e | 30

6.3.OUTPUT SCREEN:
p a g e | 31
p a g e | 32
p a g e | 33
p a g e | 34
p a g e | 35
p a g e | 36
p a g e | 37
p a g e | 38
p a g e | 39
 p a g e | 40

7.USER MANUAL

7.1.PYTHON INSTALLATION:

Step 1 − Select Version of Python to Install

Python has various versions available with differences between the syntax and

working of different versions of the language. We need to choose the version which we want

to use or need. There are different versions of Python 2 and Python 3 available.

Step 2 − Download Python Executable Installer

On the web browser, in the official site of python (www.python.org), move to the

Download for Windows section. All the available versions of Python will be listed. Select the

version required by you and click on Download. Let suppose, we chose the Python 3.9.1

version.

On clicking download, various available executable installers shall be visible with different

operating system specifications. Choose the installer which suits your system operating

system and download the installer. Let suppose, we select the Windows installer (64 bits).

The download size is less than 30MB.

 p a g e | 41

Step 3 − Run Executable Installer

We downloaded the Python 3.9.1 Windows 64 bit installer. Run the installer. Make sure

to select both the checkboxes at the bottom and then click Install New.

On clicking the Install Now, The installation process starts.

 p a g e | 42

The installation process will take few minutes to complete and once the installation is

successful, the following screen is displayed.

 p a g e | 43

Step 4 − Verify Python is installed on Windows

To ensure if Python is successfully installed on your system. Follow the given steps − 

Open the command prompt.

 Type ‘python’ and press enter

 The version of the python which you have installed will be displayed if the python is

successfully installed on your windows.

Step 5 − Verify Pip was installed

Pip is a powerful package management system for Python software packages. Thus, make

sure that you have it installed. To verify if pip was installed, follow the given steps

 Open the command prompt.

 Enter pip –V to check if pip was installed.

 The following output appears if pip is installed successfully.

 p a g e | 44

We have successfully installed python and pip on our Windows system.

7.2.MySQL Installation:

The default installation on any version of Windows is now much easier than it used to be, as
MySQL now comes neatly packaged with an installer. Simply download the installer
package, unzip it anywhere and run the setup.exe file.

The default installer setup.exe will walk you through the trivial process and by default will
install everything under C:\mysql.

Test the server by firing it up from the command prompt the first time. Go to the location of
the mysqld server which is probably C:\mysql\bin, and type − mysqld.exe --console

NOTE − If you are on NT, then you will have to use mysqld-nt.exe instead of mysqld.exe
If all went well, you will see some messages about startup and InnoDB. If not, you may have
a permissions issue. Make sure that the directory that holds your data is accessible to
whatever user (probably MySQL) the database processes run under.

MySQL will not add itself to the start menu, and there is no particularly nice GUI way to stop
the server either. Therefore, if you tend to start the server by double clicking the mysqld
 p a g e | 45

executable, you should remember to halt the process by hand by using mysqladmin, Task
List,
Task Manager, or other Windows-specific means.

Verifying MySQL Installation

After MySQL, has been successfully installed, the base tables have been initialized and the
server has been started: you can verify that everything is working as it should be via some
simple tests.

Use the mysqladmin Utility to Obtain Server Status

Use mysqladmin binary to check the server version. This binary would be available in
/usr/bin on Linux and in C:\mysql\bin on
windows.

[root@host]# mysqladmin --version

It will produce the following result on Linux. It may vary depending on your installation −
mysqladmin Ver 8.23 Distrib 5.0.9-0, for redhat-linux-gnu on i386

If you do not get such a message, then there may be some problem in your installation and
you would need some help to fix it.

Execute simple SQL commands using the MySQL Client

You can connect to your MySQL server through the MySQL client and by using
the mysql command. At this moment, you do not need to give any password as by default it
will be set as blank.

You can just use following command −

[root@host]# mysql
It should be rewarded with a mysql> prompt. Now, you are connected to the MySQL server
and you can execute all the SQL commands at the mysql> prompt as follows −

mysql> SHOW DATABASES;

 p a g e | 46

+----------+
| Database |
+----------+
| mysql |
| test |
+----------+
2 rows in set (0.13 sec)
Post-installation Steps
MySQL ships with a blank password for the root MySQL user. As soon as you have
successfully installed the database and the client, you need to set a root password as given in
the following code block −

[root@host]# mysqladmin -u root password "new_password";

Now to make a connection to your MySQL server, you would have to use the following
command
−
[root@host]# mysql -u root -p
Enter password:*******
UNIX users will also want to put your MySQL directory in your PATH, so you won't have to
keep typing out the full path every time you want to use the command-line client. For bash, it
would be something like − export PATH = $PATH:/usr/bin:/usr/sbin

Running MySQL at Boot Time

If you want to run the MySQL server at boot time, then make sure you have the following
entry in the /etc/rc.local file.

/etc/init.d/mysqld start
Also, you should have the mysqld binary in the /etc/init.d/ directory.

Python MySQL Connectivity

 p a g e | 47

Interface Python with SQL database

♦ Connecting SQL with Python

♦ creating database connectivity application
♦ Performing insert, delete, update, queries
♦ Display data by using fetchone(), fetchall(),fetchmany(), rowcount()
Database connectivity
Database connectivity refers to connection and communication between an application and a
database system.

The term “front-end” refers to the user interface, while “back-end” means the server
application and database that work behind the scenes to deliver information to the user.
mysql.connector-Library or package to connect from python to MySQL.

Before we connect the program with mysql, we need to install connectivity package named
mysql-connector-python.

Command to install connectivity package:

pip install mysql-connector-python
Command to import connector:-
Import mysql.connector

Steps for python MySQL connectivity

Step 1: Install Python
Step 2: Install MySQL
Step 3: Open Command prompt & Switch on internet connection
Step 4: Type pip install mysql-connector-python and execute
Step 5: Open python IDLE
Step 6: Import mysql.connector

Steps for creating database connectivity applications

 p a g e | 48

Step 1: Start Python: Start python editor to create your python script
Step 2: mysql.connector package
Step 3: Establishing connection to MySQL DATABASE
We need to establish a connection to a mysql database using connect() function of
mysql.connector package.

The connect statement creates a connection to the mysql server and returns a MySQL
connection object.

Syntax:
<Connection object>=mysql.connectorconnect (host=<hostname>, user=<username>,
passwd
<password>, database=<dbname>) import mysql.connector
con=mysql.connector.connect(host=”localhost”, user=”root”, passwd=” “)

Creating a cursor Object:

It is a useful control structure of database connectivity. It will let us execute all the queries we
need. Cursor stores all the data as a temporary container of returned data and allows traversal
so that we can fetch data one row at a time from cursor. Cursors are created by the
connection.cursor() method.

Syntax:
<cursor object>=<connectionobject> .cursor()
Eg: Cursor=con.cursor()
Execute SQL query:
We can execute SQL query using execute() function

Syntax:
<cursor object>.execute(SQL QUERY)
Eg: cursor.execute(“select* from data”)
The above code will execute the sql query and store the retrieved records (resultset) in the
cursor object(cursor).
 p a g e | 49

Result set refers to a logical set of records that are fetched from the database by executing a
sql query and made available in the program.
 p a g e | 50

8 . FUTURE ENHANCEMENTS

As educational technology continues to evolve, the necessary enhancements to our educational

app documentation must align with the dynamic landscape of digital learning. This document

outlines potential future enhancements aimed at improving user experience, accessibility, and

overall effectiveness of the application.

1.Interactive User Guides :

To cater to diverse learning styles, incorporating interactive user guides within the

documentation will facilitate a more engaging experience. These guides can include video

tutorials, quizzes, and step-by-step walkthroughs that allow users to understand features and

functionalities in a more hands-on manner.

2.Personalized Learning Paths:

Future documentation can be enhanced by integrating personalized learning paths that adapt to

individual user progress and preferences. By using algorithms to analyze user interactions, the

documentation can suggest relevant resources and sections tailored to each user’s unique

journey, ultimately fostering a more effective learning environment.

3.Enhanced Search Functionality:

The implementation of advanced search capabilities within the documentation is essential.

Features such as natural language processing and keyword tagging will enable users to find

information quickly and efficiently. Including a search suggestion function will further
 p a g e | 51

streamline this process, directing users to pertinent solutions and resources based on their

inquiries.

4. Incorporation of User Feedback Mechanisms:

Establishing a robust feedback system within the documentation will allow users to report

issues, suggest changes, and share their experiences. This real-time feedback can be

instrumental in continuously refining and updating content based on actual user needs and

challenges.

5. Accessibility Improvements:

To ensure inclusivity, enhancing documentation accessibility is paramount. Implementing

text-to-speech options, providing transcripts for multimedia content, and adhering to WCAG

(Web Content Accessibility Guidelines) will ensure that users with different abilities can

easily navigate and comprehend the information provided.

6. Multilingual Support:

As our user base expands globally, offering multilingual support in our documentation will

enhance usability for non-English speakers. This not only broadens accessibility but also

demonstrates a commitment to catering to a diverse audience.

7. Regular Updates and Version Control:

To maintain accuracy and relevance, establishing a schedule for regular updates and

incorporating version control will ensure that users are always informed of the latest features,
 p a g e | 52

improvements, and bug fixes. Clear version logs will provide transparency and enhance user

trust.

By implementing these future enhancements, we can significantly improve the quality and

impact of our educational app documentation, ultimately contributing to a more effective

learning experience for users around the globe.

 p a g e | 53

9..BIBILOGRAPHY:

 BOOK REFERENCES:

 Computer Science With Python – Sumita Arora

 Computer Science With Python – Preeti Arora

 NCERT Book for Computer-Science

 WEB REFERENCES:

 https://www.geeksforgeeks.org/courses/CS-12

 https://www.teachoo.com/subjects/computer-science/class-12/

 https://kvcoders.in/class-12-new-content/python-project/#google_vignette

 https://csipacademy.com

 https://pythonclassroomdiary.wordpress.com

 https://knowpythonbytes.blogspot.com

 https://python4csip.com/

 https://www.w3schools.com/