BUILD ALEXA USING PYTHON

A Project work submitted in partial fulfillment of the requirements for

the degree of
Bachelor of Computer Applications
To the
Periyar University, Salem-11
By
BHARATH S
[C21UG155CAP006]

PG & RESEARCH DEPARTMENT OF

COMPUTER SCIENCE
DON BOSCO COLLEGE
(Affiliated to Periyar University, Salem-11)
DHARMAPURI - 636 809

MAR/APR – 2024
Mr. VADAMALAI,
Assistant Professor,
PG & Research Department of Computer
Science, Don Bosco College,
Dharmapuri - 636 809.

Place:

Dharmapuri.

Date :

CERTIFICATE
This is to certify that the project work entitled “BUILD ALEXA” submitted in partial
fulfillment of the requirements of the degree of Bachelor Of Computer Applications to the
Periyar University, Salem is record of bonafide work carried out by BHARATH S
[REG.NO:C21UG155CAP006] under my supervision and guidance.

Head of the Department Signature of the Guide

[With Seal] [With Seal]

Submitted for the viva-voce Examination held on…03-04-2024…………

Internal Examiner External Examiner

[With Seal] [With Seal]

 DECLARATION

I hereby declare that the project entitled “BUILD ALEXA USING

PYTHON” submitted to the Periyar University, Salem in partial fulfillment of the
requirements for the award of the degree of Master of Science in Computer Science is
a record of original work done by me under the supervision and guidance of. Mr.
VADAMALAI, M.C.A., M.Phil., SET. Assistant Professor PG & Research
Department of Computer Science, Don Bosco College, Dharmapuri and that it has
not previously formed the basis of the award of any Degree, Diploma, Associate ship,
Fellowship or any other similar title of any University or Institution.

Place : Dharmapuri Signature of candidate

Date : BHARATH S
 ACKNOWLEDGEMENT

I thank the almighty God for the blessings that have been showered upon me to
complete the project successfully. I express my heartfelt thanks to my parents who have
encouraged me in all ways to do my project.

I wish to express my thanks to Rev. Fr. Dr. Rabert Ramesh Babu SDB, Secretary and
Rector, Don Bosco College, Dharmapuri, for his constant encouragement.

I render my special thanks to Rev. Fr. Dr. J. Angelo Joseph SDB, Principal, and
Rev.Fr. Dr. S. Bharathi Bernadsha SDB, Vice-Principal, from Don Bosco College,
Dharmapuri, for their support and constant encouragement.

I am highly thankful to Mr. S. Vadamalai M.C.A., M.Phil., B.Ed., Head, UG&PG

Research Department of Computer Science, Don Bosco College, Dharmapuri, for his
valuable guidance, encouragement, and keen interest in completion of my project work.

I also take the opportunity to express my gratitude to my Guide Mr.P.Ramachandran,

M.Sc., M.Phil., B.Ed., Assistant Professor, UG & PD Research Department of Computer
Science, Don Bosco College, Dharmapuri, for her outstanding computing workmanship
evinced in executing my project work.

I also take the opportunity to express my gratitude to my Class In charge Mr. S.

Michael Bosco Duraisamy, M.C.A., M.Phil., Ph.D. Assistant Professor, UG & PG Research
Department of Computer Science, Don Bosco College, Dharmapuri, for her support evinced
in executing my project work.

I sincerely thank my department staff members of Don Bosco College, Dharmapuri,

for their guidance evinced in executing my project.

[BHARATH S]
 ABSTRACT

To build a simple version of Alexa using Python, you can leverage libraries like SpeechRecognition for

speech recognition, pyttsx3 for text-to-speech conversion, and some basic AI logic for handling user

queries. First, capture audio input from the user, then use SpeechRecognition to convert it to text. Process

the text to understand the user's intent using natural language processing techniques or predefined

commands. Based on the intent, perform the desired action (e.g., retrieving information from the web,

controlling smart home devices). Finally, use pyttsx3 to convert the response to speech and output it to

the user. This simple setup forms the foundation of an Alexa-like voice assistant.
 CONTENTS

Chapter No Title of the Content Page No

1 INTRODUCTION

1.1 ORGANIZATION PROFILE

1.2 SYSTEM SPECIFICATION
1.2.1 HARDWARE CONFIGURATION
1.2.2 SOFTWARE CONFIGRATION

2 SYSTEM STUDY

2.1 EXISTING SYSTEM

2.1.1 DESCRIPTION
2.1.2 DRAWBACKS
2.2 PROPOSED SYSTEM
2.2.1 DESCRIPTION
2.2.2 FEATURES

3 SYSTEM DESIGN AND DEVELOPMENT

3.1 FILE DESIGN

3.2 INPUT DESIGN
3.3 OUTPUT DESIGN
3.4 CODE DESIGN
3.5 DATABASE DESIGN
3.6 SYSTEM DEVELOPMENT
3.6.1 DISCRIPTION OF MODULES
4 TESTING AND IMPLEMENTATION

CONCULUSION
5

6 BIBLIOGRAPHY

7 APPENDENCIES

A. DATA FLOW DIAGRAM

B. TABLE STRUCTURE

C. SAMPLE CODING

D. SAMPLE INPUT

E. SAMPLE OUTPUT
 CHAPTER 1
INTRODUCTION
Introduction:

Building an Alexa-like voice assistant in Python involves integrating modules for speech
recognition, natural language understanding, and text-to-speech synthesis. Leveraging libraries such as
SpeechRecognition and pyttsx3, we capture and process user voice commands, converting them to text
and discerning intent through natural language processing techniques. This includes tasks like intent
classification and entity extraction. Once the user's intent is understood, the system generates appropriate
responses using predefined actions or by fetching information from online sources. This project aims to
create a basic yet functional voice assistant, allowing users to interact with devices using voice
commands in a Python environment. The challenge lies in optimizing accuracy, responsiveness, and the
ability to handle a diverse range of user queries effectively, simulating the capabilities of commercial
voice assistants like Alexa.
1.1 ORGANIZATION PROFILE
1.2. SYSTEM SPECIFICATION

1.2.1. HARDWARE CONFIGURATION

 Processor : Pentium or higher versions

 RAM : 4 GB

 Hard disk capacity : SSD 460 GB

 System type : 64-bit operating system

1.2.2. SOFTWARE SPECIFICATION

 Operating System : Windows 10 Pro

 Front-end : PYTHON
CHAPTER II
SYSTEM
STUDY
2.0. SYSTEM STUDY
2.1. Existing System
2.1.1. Drawbacks

 One drawback of building an Alexa-like voice assistant in Python is performance

limitations. Python, being an interpreted language, can be slower compared to compiled
languages like C++ or Java, especially when handling complex tasks like real-time speech
recognition and natural language processing.

 This can lead to delays in response times, affecting the user experience.

 Additionally, Python's memory usage might be higher compared to other languages,

which could be problematic when running on devices with limited resources, such as IoT
devices or older hardware.

 Another drawback is the dependency on external libraries and services for speech
recognition and natural language understanding. These services might have usage limits,
incur costs, or be subject to outages, affecting the reliability and availability of the voice
assistant.

 Lastly, Python's Global Interpreter Lock (GIL) can hinder concurrency and parallelism,
potentially limiting the scalability of the voice assistant for handling multiple user
requests simultaneously.
 2.2. Proposed System:

2.2.1. Description

To build an Alexa-like voice assistant in Python, you'll need to integrate various modules
for speech recognition, natural language understanding, and text-to-speech synthesis. Start by using a
library like Speech Recognition to capture and process user voice commands, converting them to text.
Next, employ natural language processing techniques, possibly using libraries like NLTK or spaCy, to
analyze and understand the user's intent from the text. Implement logic to interpret the intent and execute
appropriate actions, such as fetching information from online sources or controlling smart home devices.
Finally, use a library like pyttsx3 to convert the response text into speech and output it to the user. This
project involves combining these modules effectively to create a functional and interactive voice
assistant similar to Alexa.

2.2.2. Features

 Speech Recognition

 Natural Language Understanding (NLU)

 Intent Interpretation

 Action Execution

 Text-to-Speech Synthesis

 Conversational Interface

 Error Handling

 Integration

 Scalability and Performance

 User Feedback and Improvement

 CHAPTER III
SYSTEM DESIGN AND DEVELOPMENT
3.1 FILE DESIGN
3.2. INPUT DESIGN
3.3. OUTPUT DESIGN
3.4. CODE DESIGN
3.5. SYSTEM DEVELOPMENT

System development involves creating software systems that meet specific requirements, and building an
Alexa-like system with a GUI in Python requires careful consideration of design, implementation, and
integration of various components. In approximately 150 lines of code, we can create a basic version of
such a system.

The first step is to design the graphical user interface (GUI) using a library like Tkinter. The GUI
typically consists of input fields for user queries and output areas for displaying responses. In our
implementation, we'll use Tkinter to create a simple interface with an entry field for queries and a label
for displaying responses.

Next, we need to implement functionality for processing user queries and generating appropriate
responses. This involves analyzing the user's input to determine their intent and then generating a
response based on that intent. For simplicity, we'll use keyword matching to identify common queries
such as asking for the time or weather.

Additionally, to make our system more interactive, we can integrate speech recognition and text-to-
speech functionality. Speech recognition allows users to input queries via voice commands, while text-
to-speech converts system responses into speech for the user. We'll use the SpeechRecognition library for
speech input and pyttsx3 for text-to-speech conversion.

Our system development process will include the following steps:

1. GUI Design: We'll design a basic GUI using Tkinter, consisting of an entry field for queries and a
label for displaying responses.

2. Query Processing: We'll implement logic to process user queries and generate responses based on
keyword matching. Common queries such as asking for the time or weather will trigger predefined
responses.

3. Speech Recognition Integration: We'll integrate speech recognition using SpeechRecognition library to
capture user input via voice commands.

4. Text-to-Speech Conversion: We'll implement text-to-speech functionality using pyttsx3 to convert

system responses into speech for the user.

5. Testing and Refinement: We'll thoroughly test the system to ensure it functions as expected, refining
the implementation as needed to improve performance and user experience.

3.6.1. DESCRIPTION OF MODULES

Modules Lists:

 GUI Module (Tkinter)

 Speech Recognition Module (SpeechRecognition)
 Text-to-Speech Module (pyttsx3)
 Query Processing Module
 System Integration Module
 Keyword Database Module
 User Interaction Module
 Error Handling Module

GUI Module (Tkinter):

 This module is responsible for creating the graphical user interface (GUI) of the Alexa-like
system.
 It defines and manages various GUI elements such as windows, buttons, labels, and entry fields.
 Handles user interactions and events within the GUI interface, such as button clicks and
text input.

Query Processing Module:

 The Query Processing Module processes user queries to understand their intent and context.
 It contains algorithms and logic to analyze user input and extract relevant information.
 Identifies keywords or patterns in the query to determine the user's request or command.
Speech Recognition Module (SpeechRecognition):

 This module integrates speech recognition functionality into the system.

 It captures audio input from the user's microphone and converts it into text.
 Utilizes the SpeechRecognition library to perform speech-to-text conversion.

Text-to-Speech Module (pyttsx3):

 The Text-to-Speech Module converts system responses into spoken audio.

 It takes text-based responses generated by the system and synthesizes them into audible speech.
 Uses pyttsx3 library for text-to-speech conversion, allowing the system to "speak" the
responses to the user.

System Integration Module:

 This module orchestrates the interaction between different components of the system.
 It coordinates the flow of data and control between the GUI, query processing,
speech recognition, and text-to-speech modules.
 Manages the exchange of information and commands between modules to ensure
seamless operation.

Keyword Database Module:

 The Keyword Database Module stores predefined keywords and associated responses.
 Provides a repository for mapping user queries to appropriate responses based on keywords.
 Allows for easy modification and expansion of the system's capabilities by adding or
updating keywords and responses.

User Interaction Module:

 Handles user interaction with the GUI interface.

 Manages user input, such as querying through text input or voice commands.
 Provides feedback to the user, guiding them through the interaction process and
displaying system responses.
Error Handling Module:

 Detects and handles errors or exceptions that may occur during system operation.
 Provides error messages and prompts for users when issues arise to ensure a smooth
user experience.
 Ensures the robustness and reliability of the system by handling unexpected situations gracefully.
 CHAPTER IV

TESTING AND IMPLEMENTATION

TESTING AND IMPLEMENTATION

In the testing and implementation phase of building the Alexa-like GUI system in Python,
several steps are involved to ensure the system's functionality, reliability, and user satisfaction.

Testing:
Unit Testing:

Develop and execute unit tests for individual components of the system, such as GUI elements, query
processing, speech recognition, and text-to-speech conversion. Verify that each module performs its
intended functions correctly.

Integration Testing:

Test the integration between different modules to ensure they interact seamlessly. Verify that data
exchange and communication between the GUI, query processing, speech recognition, and text-to-speech
modules function as expected.

User Acceptance Testing (UAT):

Engage users or stakeholders to participate in user acceptance testing. Allow them to interact with the
system and provide feedback on its usability, effectiveness, and satisfaction. Address any issues or
concerns raised during UAT to improve the system's overall quality.

Regression Testing:

Conduct regression testing to validate that new changes or updates do not introduce unintended errors or
regressions in the system. Re-run existing test cases to ensure that previously working functionality
remains unaffected by modifications.

Deployment and Monitoring:

Deploy the system to production environments and monitor its performance, stability, and user
feedback. Continuously monitor system metrics and user interactions to identify any issues or areas for
improvement post-deployment. Implement updates or optimizations as necessary to enhance the system's
overall performance and user experience.

By following these testing and implementation practices, we can ensure that the Alexa-like GUI system in
Python meets its objectives effectively and delivers a reliable and satisfying user experience.

Implementation:

Setting up GUI:
Design the user interface to resemble an Alexa-like interface. Include components like a
microphone icon/button for voice input, a text area to display responses, and possibly other controls
for additional functionality.

Voice Input:

Integrate speech recognition to capture voice commands from the user. You can use libraries like
SpeechRecognition for this purpose. Make sure to handle exceptions and errors gracefully

.Processing User Input:

Once the voice command is captured, process it to understand the user's intent. This can involve natural
language understanding (NLU) techniques. You might use libraries like spaCy or NLTK for this purpose.

Interaction with Alexa Skills Kit (ASK) or APIs:

Implement the logic to interact with Alexa Skills Kit or other APIs to fulfill user requests. This might
involve sending HTTP requests to external services or using SDKs provided by the service providers.

Displaying Responses:

Once you receive a response from the service, display it in the GUI. Update the text area or relevant
components with the response text or other relevant information.

Error Handling:

Implement robust error handling throughout the application. Handle network errors, API failures, and
unexpected user inputs gracefully to provide a smooth user experience.

Testing:

Thoroughly test your application to ensure that it works as expected. Test various voice commands and
scenarios to identify and fix any bugs or issues.

Deployment:

Once the application is ready, consider packaging it for distribution. You might create an executable
installer or package it as a standalone application depending on your target platform.

Continuous Improvement:

Gather feedback from users and iterate on your application to add new features, improve usability, and
fix any issues that arise over time.
CHAPTER V
CONCLISION
 CONCLUTION

In conclusion, crafting your own Alexa-like voice assistant with a graphical user interface (GUI) using
Python presents an exciting opportunity to delve into the realms of artificial intelligence and human-
computer interaction. By harnessing Python's versatility and a myriad of libraries, this endeavor becomes
not only feasible but also enriching. Through the selection of a suitable GUI framework, such as Tkinter,
we establish the groundwork for an intuitive interface, replete with familiar elements like buttons, text
fields, and voice input functionalities.

At the heart of our endeavor lies the seamless integration of voice input and response processing.
Leveraging Python's SpeechRecognition library, we empower our application to understand and interpret
user commands, bridging the gap between human speech and machine action. By employing natural
language processing (NLP) techniques, we decode user intent, enabling our assistant to fulfill requests
with precision and efficacy.

The functionality of our application is further augmented by interfacing with external APIs or services,
ranging from weather updates to music streaming, thereby enriching the user experience with a plethora
of capabilities. Robust error handling mechanisms ensure resilience in the face of adversity, guaranteeing
a seamless user experience even amidst network disruptions or unexpected inputs
CHAPTER VI

BIBLIOGRAPH

Y
 6.0. BIBLIOGRAPHY
 Building your own Alexa-like voice assistant with a graphical user interface (GUI) in
Python requires drawing upon a variety of resources from within the Python ecosystem.
The journey begins with understanding Python programming fundamentals, which can
be gleaned from official documentation available at python.org
.
 This foundational knowledge serves as a springboard for delving into GUI development,
for which Tkinter documentation provides essential insights into constructing user-
friendly interfaces
.
 To imbue our assistant with voice recognition capabilities, we turn to the
SpeechRecognition library. Its documentation serves as a guide for integrating speech
recognition functionalities, enabling our assistant to understand and respond to user
commands effectively

 Interfacing with external APIs or services expands the functionality of our assistant,
offering features like weather updates, music playback, or task automation

WEBSITE
1. https://youtu.be/AWvsXxDtEkU?si=7nJenxD5t-EqpBE0

2. https://www.geeksforgeeks.org/python-programming-language/

3. https://chat.openai.com/

4. https://plainenglish.io/blog/build-your-own-alexa-with-just-20-lines-of-python-

ea8474cbaab7

5. www.learnpython.org
CHAPTER VII
APPENDENCIES
APPENDENCIES

A. DATAFLOW DIAGRAM

DFD INTRODUCTION

DFD is the abbreviation for Data Flow Diagram. The flow of data of a system or a
process is represented by DFD. It also gives insight into the inputs and outputs of each entity and the
process itself. DFD does not have control flow and no loops or decision rules are present. Specific
operations depending on the type of data can be explained by a flowchart. Data Flow Diagram can be
represented in several ways. The DFD belongs to structured- analysis modeling tools. Data Flow
diagrams are extremely popular because they help us to visualize the major steps and data involved in
software- system processes.

The Data Flow Diagram has four components:

1. External entities:

These are sources or destinations of data outside the system being modeled. External
entities interact with the system by providing input data or receiving output data. They are
represented by rectangles or squares in the DFD.

2. Processes:

Processes represent the functions or transformations performed on data within the system.
Each process takes input data, performs some action or manipulation, and produces output data.
Processes are depicted by circles or ovals in the DFD.

3. Data flows:

Data flows represent the movement of data between the external entities, processes, and
data stores within the system. They show how data enters the system, is processed, and exits the system.
Data flows are depicted by arrows connecting the various components of the DFD.
 4. Data stores:

Data stores represent repositories where data is stored within the system. They can
be physical or digital storage locations such as databases or files. Data stores hold data temporarily
or permanently and are depicted by rectangles with rounded corners in the DFD.

Rules for creating DFD

1. Extenal Entities:

Every DFD must have at least one external entity, which represents a source or destination of
data outside the system being modeled. External entities should be labeled descriptively and depicted as
squares or rectangles.

2. Processes:

Processes represent functions or transformations that occur within the system. Each process
should have clear inputs and outputs and should be labeled with a descriptive action phrase. Processes
are depicted as circles or ovals in the DFD.

3. Data flow:

Data flows represent the movement of data between external entities, processes, and data stores
within the system. Data flows should be labeled with meaningful names and depicted as arrows
indicating the direction of data flow.

4. Data Stores:

Data stores represent repositories where data is stored within the system. Each data store should
have at least one data flow entering and one data flow leaving it. Data stores are depicted as rectangles
with rounded corners.

5. Balenced Data Flow:

The inputs and outputs of each process must be balanced, meaning that for every input data flow,
there must be an output data flow, and vice versa. This ensures that no data is lost or created within the
system.
 6. No Crossed Lines:

Data flows should not cross each other in a DFD, as crossed lines can create confusion and
ambiguity about the flow of data within the system.

7. Consistency:

DFDs should be consistent in terms of notation, labeling, and terminology. This ensures that
stakeholders can easily understand and interpret the diagrams.

8. Levels Of Details:

DFDs can have multiple levels of detail, with each level providing a different perspective on the
system. Higher-level DFDs show a broader view of the system, while lower-level DFDs provide more
detailed views of specific processes.

9. Context Diagram:

The highest-level DFD, known as the context diagram, provides an overview of the entire system,
showing external entities and the interactions between them. It serves as a starting point for creating
more detailed DFDs.

10. Modularity:

DFDs should be modular, with each process representing a single function or transformation.
This makes the diagrams easier to understand and maintain.

Levels of DFD

Uses hierarchy to maintain transparency thus multilevel DFD’s can be created.

Levels of DFD are as follows:
4.6 0-level DFD

4.7 1-level DFD

4.8 2-level DFD

Advantages of DFD:

1. Clarity Of Communication:

DFDs provide a clear and visual representation of the flow of data within a system. This
clarity makes it easier for stakeholders, including analysts, developers, and end-users, to understand how
the system operates

2. System Understading:

DFDs help stakeholders gain a comprehensive understanding of the system's structure and
functionality. By depicting processes, data flows, and interactions with external entities, DFDs facilitate
discussions about system requirements, behavior, and potential improvements.

3. Scalability:

DFDs can be scaled to represent systems of varying complexities. From high-level context
diagrams that provide an overview of the entire system to detailed diagrams that capture individual
processes and data flows, DFDs can accommodate different levels of abstraction and detail.

4. Modularity:

DFDs promote a modular approach to system design and analysis. Processes are decomposed
into smaller, manageable units, making it easier to identify and address specific components of the
system. This modularity enhances maintainability and facilitates system evolution over time.

5. Identifying Data Dependencies:

DFDs highlight data dependencies and interactions between different parts of the system. By
tracing data flows across processes and data stores, stakeholders can identify potential bottlenecks,
redundancies, or areas for optimization.
Disadvantages of DFD:

1. Limitted Details:

DFDs provide a high-level overview of the system's functionality and data flows, which may
lack the detail required for complex systems. In some cases, stakeholders may require more detailed
diagrams or additional documentation to fully understand the system's intricacies

2. Focus On Data Flow:

DFDs primarily focus on the flow of data within the system, often overlooking other important
aspects such as control flow, user interfaces, and system interactions. This narrow focus may lead to
oversimplified representations of the system's behavior.

3. Complexity Management:

As systems grow in complexity, managing and updating DFDs can become challenging.
Decomposing processes into smaller subprocesses and maintaining consistency across multiple levels of
DFDs requires careful planning and documentation.

4. Subjective In Processs Identificatin:

Identifying and defining processes in a DFD can be subjective, as different stakeholders may
have varying interpretations of system functionality. This subjectivity can lead to inconsistencies or
disagreements in the representation of the system.

5. Difficulty In Representing Real-Time System:

DFDs are not well-suited for modeling real-time systems or systems with complex timing
constraints. Representing time-sensitive processes, event-driven behavior, or asynchronous
communication can be challenging using traditional DFDs.
DATA FLOW DIAGRAM
 B. TABLE STRUCTURE

Building an Alexa-like GUI involves designing a user interface that mimics the functionality of the
Amazon Alexa voice assistant. Here are some points to consider when structuring the table for such a GUI:

1. Commands Table:

 This table stores the various voice commands supported by the GUI.
 Columns may include: Command ID, Command Name, Description, and
Associated Function/Action.

2. User Profile Table:

 Stores user information and preferences.

 Columns may include: User ID, Name, Email, Language Preference, Timezone, etc.

3. Device Control Table:

 Manages the control of smart devices linked to the GUI.

 Columns may include: Device ID, Device Name, Device Type (e.g., lights, thermostat), Current
State (e.g., on/off), and Associated User.

4. History/Logs Table:

 Records user interactions and responses.

 Columns may include: Timestamp, User ID, Command, Response, and Status (e.g., success,
failure).

5. Settings Table:

 Stores configuration settings for the GUI.

 Columns may include: Setting ID, Setting Name, Value, and Description.
6. Contextual Information Table:

 Holds contextual information related to ongoing interactions.

 Columns may include: Session ID, Context Type (e.g., weather, news), Context Data, and Expiry
Time.

7. Language Support Table:

 Stores language-specific configurations and translations.

 Columns may include: Language ID, Language Name, Translation Key, and Translation Text.

8. Authorization/Access Control Table:

 Manages user access rights and permissions.

 Columns may include: User ID, Role, Access Level, and Authorized Features.

9. Feedback/Suggestions Table:

 Collects user feedback and suggestions for improvement.

 Columns may include: Feedback ID, User ID, Feedback Type, Feedback Text, and Timestamp.

10. Session Management Table:

 Tracks active sessions and session-related data.

 Columns may include: Session ID, User ID, Start Time, End Time, and Session Stat
 C. SAMPLE CODING

Optimus virtual assistant.py:

import tkinter as tk
import speech_recognition as sr
import pyttsx3
import pywhatkit
import datetime
import wikipedia
import pyjokes
import webbrowser
import subprocess
import os
import ecapture
from ecapture import ecapture as ec

listener = sr.Recognizer()
engine = pyttsx3.init()
voice = engine.getProperty('voices')
engine.setProperty('voices',voice[1].id)

def process_input():
recognizer =
sr.Recognizer() try:

with sr.Microphone() as source:

recognizer.adjust_for_ambient_noise(source)
audio = recognizer.listen(source)
user_input = recognizer.recognize_google(audio)
input_field.delete(1.0, tk.END)
 input_field.insert(tk.END, user_input)
response = get_assistant_response(user_input)
assistant_output.config(text=response)
speak(response)

except sr.UnknownValueError:
assistant_output.config(text="Sorry, I couldn't understand that.")
except sr.RequestError:
assistant_output.config(text="Sorry, there was an error with the service.")

def get_assistant_response(input_text):

if "play" in input_text.lower():
song = input_text.replace('play','')
return 'Playing...'
speak('playing'+song)
pywhatkit.playonyt(song)

elif "weather" in input_text.lower():

return "The weather today is sunny."

elif "time" in input_text.lower():

now = datetime.datetime.now()
current_time = now.strftime("%I:%M %p")
print(current_time)
return ("The current time is " + current_time)

elif 'who is' in input_text.lower():

person = input_text.replace('who is','')
info = wikipedia.summary(person,2)
print(info)
return(info)

elif 'joke' in input_text.lower():

speak(pyjokes.get_joke())
 elif 'hello' in input_text.lower():
return 'hi! what can i do for
u'

elif 'how are you' in input_text.lower():

return 'i am good! thank for asking!

elif 'what is your name is' in input_text.lower():

return 'i am your optimus'

elif 'i love you' in input_text.lower():

print('i am already relationship with wifi')
return 'i am already relationship with wifi'

elif 'bye' in input_text.lower():

return 'quit'

elif 'open google' in input_text.lower():

webbrowser.open("google.com")
print('Opening...')
return 'Opening google'

elif 'open youtube' in input_text.lower():

webbrowser.open("youtube.com")
print('Opening...')
return 'Opening youtube'

elif 'open geeksforgeeks' in input_text.lower():

webbrowser.open("geeksforgeeks.org")
print('Opening...')
return 'Opening geeksforgeeks'

elif 'who made you' in input_text.lower():

return 'I have been created by bharath'

elif 'search' in input_text.lower():

engine = input_text.replace('search','')
 webbrowser.open(engine)
return 'searching...'
print('searching...')

elif 'ppt' in input_text.lower():

power = r"C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Microsoft Office 2013"
os.startfile(power)
return 'opening power point presentation'
print('Opening power point presentation')

elif 'chrome' in input_text.lower():

power = r"C:\Program Files\Google\Chrome\Application"
os.startfile(power)
return 'opening chrome'
print('Opening chrome')

elif 'word' in input_text.lower():

power = r"C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Microsoft Office 2013"
os.startfile(power)
return 'opening word'
print('Opening word')

elif 'excel' in input_text.lower():

power = r"C:\ProgramData\Microsoft\Windows\Start Menu\Programs\Microsoft Office 2013"
os.startfile(power)
return 'opening excel'
print('Opening excel')

elif 'restart' in input_text.lower():

subprocess.call(["shutdown / r"])

elif 'camera' in input_text.lower():

ec.capture(0,"jarvis camera","img.jpg")
return 'opening camera...'

else:
return "please say the command again."
def speak(text):
engine = pyttsx3.init()
engine.say(text)
engine.runAndWait()

root = tk.Tk()
root.title("Optimus Assistant")

input_field = tk.Text(root, height=4, width=50)

input_field.pack(pady=10)

voice_input_button = tk.Button(root, text="🎙", command=process_input)

voice_input_button.pack()

assistant_output = tk.Label(root, text="", wraplength=400)

assistant_output.pack(pady=10)

root.mainloop()
 D. SAMPLE INPUT:

Optimus virtual assistant.py:

E. SAMPLE OUTPUT:
Future Enhancement

In future iterations of building a GUI for the Alexa voice assistant using Python, there are
several avenues for enhancement that could significantly elevate the user experience and
functionality. One crucial aspect is refining the natural language understanding (NLU)
capabilities. Integrating cutting-edge NLP algorithms can empower Alexa to grasp user
intents more accurately, leading to more precise responses and interactions.

Moreover, personalization is key to fostering deeper engagement with the voice assistant.
Introducing user profiles could enable Alexa to tailor its responses based on individual
preferences and usage patterns. By learning from past interactions, Alexa could provide more
relevant suggestions and assistance, creating a more personalized and adaptive experience for
each user.

Expanding language support is another vital enhancement. As Alexa continues to gain

popularity globally, offering support for multiple languages becomes increasingly important.
By accommodating diverse linguistic backgrounds, the voice assistant can reach a broader
audience and serve users from different regions more effectively.

Future:
 Natural language understanding
 Personalization
 Multi-language Support
 Custom Skills Development
 Enhanced Accessibility Features
 Visual Feedback:
 Expanded Integration
 Contextual Understanding
 Machine Learning Enhancements
 Security and Privacy