Python Project - Basic Calendar App with Tkinter and PyQt5
Calendar App:
Create a basic calendar application that allows users to add events.
Input values:
User interacts with the calendar application by adding events, specifying event details such as date, time, and description.
Output value:
Visual representation of the calendar with added events and feedback on user actions (addition, deletion).
Example:
Input values: 1. Add an event - Input event date: 2015-02-15 - Input event time: 10:00 AM - Input event description: Meeting with the client. Output value: Calendar app displays the event "Meeting with client" on February 15, 2015, at 10:00 AM. Input values: 2. Add another event - Input event date: 2015-02-20 - Input event time: 2:30 PM - Input event description: Team brainstorming session Output value: Calendar app displays the event "Team brainstorming session" on February 20, 2015, at 2:30 PM. Input values: 3. Delete an event - Input event date to delete: 2015-02-15 - Input event time to delete: 10:00 AM Output value: Calendar app removes "Meeting with client" from February 15, 2015. Input values: 4. View the calendar Output value: Calendar app displays all scheduled events for the month.
Here are two different solutions for a Calendar Application that allows users to add, delete, and view events with a simple user interface. Each solution uses different frameworks: Tkinter for the first solution and PyQt5 for the second.
Solution 1: Calendar App Using Tkinter
This solution uses the Tkinter library, which is a built-in GUI toolkit in Python, to create a basic calendar application with a simple user interface.
Code:
# Solution 1: Calendar App Using Tkinter
from tkinter import Tk, Label, Button, Entry, StringVar, messagebox
from tkcalendar import Calendar
import datetime
class CalendarApp:
"""Class to create a Calendar Application using Tkinter."""
def __init__(self, root):
"""Initialize the CalendarApp with the main Tkinter window."""
self.root = root
self.root.title("Basic Calendar App")
self.events = {} # Dictionary to store events
# Calendar widget
self.cal = Calendar(root, selectmode='day', year=2024, month=1, day=1)
self.cal.grid(row=0, column=0, columnspan=4, padx=10, pady=10)
# Event details entry fields
self.date_var = StringVar()
self.time_var = StringVar()
self.desc_var = StringVar()
Label(root, text="Event Date (YYYY-MM-DD):").grid(row=1, column=0)
self.date_entry = Entry(root, textvariable=self.date_var)
self.date_entry.grid(row=1, column=1)
Label(root, text="Event Time (HH:MM AM/PM):").grid(row=2, column=0)
self.time_entry = Entry(root, textvariable=self.time_var)
self.time_entry.grid(row=2, column=1)
Label(root, text="Event Description:").grid(row=3, column=0)
self.desc_entry = Entry(root, textvariable=self.desc_var)
self.desc_entry.grid(row=3, column=1)
# Add and Delete buttons
add_button = Button(root, text="Add Event", command=self.add_event)
add_button.grid(row=4, column=0, pady=10)
delete_button = Button(root, text="Delete Event", command=self.delete_event)
delete_button.grid(row=4, column=1, pady=10)
view_button = Button(root, text="View Events", command=self.view_events)
view_button.grid(row=4, column=2, pady=10)
def add_event(self):
"""Add an event to the calendar."""
event_date = self.date_var.get()
event_time = self.time_var.get()
event_desc = self.desc_var.get()
# Validate input
if not event_date or not event_time or not event_desc:
messagebox.showwarning("Input Error", "All fields are required.")
return
try:
datetime.datetime.strptime(event_date, '%Y-%m-%d')
except ValueError:
messagebox.showwarning("Input Error", "Invalid date format. Use YYYY-MM-DD.")
return
# Add event to dictionary
self.events[(event_date, event_time)] = event_desc
messagebox.showinfo("Event Added", f"Event '{event_desc}' added on {event_date} at {event_time}.")
self.clear_inputs()
def delete_event(self):
"""Delete an event from the calendar."""
event_date = self.date_var.get()
event_time = self.time_var.get()
# Validate input
if not event_date or not event_time:
messagebox.showwarning("Input Error", "Event date and time are required for deletion.")
return
# Remove event if exists
if (event_date, event_time) in self.events:
del self.events[(event_date, event_time)]
messagebox.showinfo("Event Deleted", f"Event on {event_date} at {event_time} has been deleted.")
else:
messagebox.showwarning("Event Not Found", "No event found for the given date and time.")
self.clear_inputs()
def view_events(self):
"""View all events on the calendar."""
events_list = "\n".join([f"{date} at {time}: {desc}" for (date, time), desc in self.events.items()])
if events_list:
messagebox.showinfo("All Events", events_list)
else:
messagebox.showinfo("No Events", "No events found.")
def clear_inputs(self):
"""Clear the input fields."""
self.date_var.set("")
self.time_var.set("")
self.desc_var.set("")
# Run the Tkinter calendar application
root = Tk()
app = CalendarApp(root)
root.mainloop()
Output:
Explanation:
- Tkinter Setup:
- Creates a main window using Tkinter and initializes the calendar with the tkcalendar library.
- Event Dictionary:
- Uses a dictionary (self.events) to store events with keys as (date, time) tuples and values as event descriptions.
- Adding Events:
- Users input the date, time, and description of the event, which is then validated and added to the event dictionary.
- Deleting Events:
- Deletes events by matching the date and time provided by the user.
- Viewing Events:
- Displays all events stored in the dictionary using a messagebox.
Solution 2: Calendar App Using PyQt5
This solution uses the PyQt5 library to create a calendar application with a graphical user interface.
Code:
# Solution 2: Calendar App Using PyQt5
from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton, QVBoxLayout, QWidget, QLineEdit, QMessageBox, QCalendarWidget
import sys
class CalendarApp(QMainWindow):
"""Class to create a Calendar Application using PyQt5."""
def __init__(self):
"""Initialize the CalendarApp with the main PyQt5 window."""
super().__init__()
self.setWindowTitle("Basic Calendar App")
self.setGeometry(100, 100, 400, 400)
self.events = {} # Dictionary to store events
# Set up the user interface
self.setup_ui()
def setup_ui(self):
"""Set up the user interface with widgets."""
central_widget = QWidget()
layout = QVBoxLayout()
# Calendar widget
self.calendar = QCalendarWidget(self)
layout.addWidget(self.calendar)
# Event details entry fields
self.date_input = QLineEdit(self)
self.date_input.setPlaceholderText("Enter Date (YYYY-MM-DD)")
layout.addWidget(self.date_input)
self.time_input = QLineEdit(self)
self.time_input.setPlaceholderText("Enter Time (HH:MM AM/PM)")
layout.addWidget(self.time_input)
self.desc_input = QLineEdit(self)
self.desc_input.setPlaceholderText("Enter Event Description")
layout.addWidget(self.desc_input)
# Add, Delete, and View buttons
add_button = QPushButton("Add Event", self)
add_button.clicked.connect(self.add_event)
layout.addWidget(add_button)
delete_button = QPushButton("Delete Event", self)
delete_button.clicked.connect(self.delete_event)
layout.addWidget(delete_button)
view_button = QPushButton("View Events", self)
view_button.clicked.connect(self.view_events)
layout.addWidget(view_button)
central_widget.setLayout(layout)
self.setCentralWidget(central_widget)
def add_event(self):
"""Add an event to the calendar."""
event_date = self.date_input.text()
event_time = self.time_input.text()
event_desc = self.desc_input.text()
# Validate input
if not event_date or not event_time or not event_desc:
QMessageBox.warning(self, "Input Error", "All fields are required.")
return
# Add event to dictionary
self.events[(event_date, event_time)] = event_desc
QMessageBox.information(self, "Event Added", f"Event '{event_desc}' added on {event_date} at {event_time}.")
self.clear_inputs()
def delete_event(self):
"""Delete an event from the calendar."""
event_date = self.date_input.text()
event_time = self.time_input.text()
# Validate input
if not event_date or not event_time:
QMessageBox.warning(self, "Input Error", "Event date and time are required for deletion.")
return
# Remove event if exists
if (event_date, event_time) in self.events:
del self.events[(event_date, event_time)]
QMessageBox.information(self, "Event Deleted", f"Event on {event_date} at {event_time} has been deleted.")
else:
QMessageBox.warning(self, "Event Not Found", "No event found for the given date and time.")
self.clear_inputs()
def view_events(self):
"""View all events on the calendar."""
events_list = "\n".join([f"{date} at {time}: {desc}" for (date, time), desc in self.events.items()])
if events_list:
QMessageBox.information(self, "All Events", events_list)
else:
QMessageBox.information(self, "No Events", "No events found.")
def clear_inputs(self):
"""Clear the input fields."""
self.date_input.clear()
self.time_input.clear()
self.desc_input.clear()
# Run the PyQt5 calendar application
app = QApplication(sys.argv)
window = CalendarApp()
window.show()
sys.exit(app.exec_())
Output:
Explanation:
- PyQt5 Setup:
- Uses PyQt5 to create a GUI application with a calendar widget, input fields, and buttons for user interaction.
- Event Storage:
- Stores events in a dictionary (self.events) with keys as (date, time) and values as event descriptions.
- Add Event:
- Adds an event after validating the input fields for date, time, and description.
- Delete Event:
- Deletes an event by matching the provided date and time.
- View Events:
- Displays all scheduled events in a message box.
- Clear Inputs:
- Clears the input fields after adding or deleting events.
Both solutions effectively create a basic calendar application with event management functionality using two different GUI libraries (Tkinter and PyQt5). Each provides a different approach to creating a graphical user interface for a calendar app.
- Weekly Trends and Language Statistics
- Weekly Trends and Language Statistics