Project Report On

CAMPUS LOST & FOUND SEARCH SYSTEM

SUBMITTED BY: SUBMITTED TO:

Abhay Choudhary Deepali Saini

E12444
UID: 25MCI10298
CLASS: MCA(AI/ML)
SECTION: 25MAM

-
 TABLE OF CONTENT
[Link]……..……………………………………………….01
[Link]………………………………………………………01
[Link]…………………………………………………………02
[Link] Used………………………………………………….02
[Link]……………………………………………………..03
[Link] Design…………………………………………………….03
[Link]………………………………………………………………09-14
[Link]……………………………………………………………15-16
[Link]…………………………………………………………17
[Link]…………………………………………………………17
1. INRODUCTION :-

The Campus Lost & Found Search System is a digital solution developed to streamline
the process of managing lost and found items within a university campus.
In large educational institutions, misplaced items like ID cards, wallets, books, or
phones are a common issue. Manual notice boards are inefficient and time consuming.

This project introduces an automated platform built using Python Tkinter for GUI and
SQLite for local data storage. It records lost/found item details, provides keyword
search, and performs auto-matching between lost and found entries.

The system ensures:

• Better communication among students and campus authorities

• Faster recovery of items
• Transparent digital tracking

2. BACKGROUND:-

Traditional lost and found systems rely heavily on paper logs or notice boards,
which are error-prone and lack accessibility. Due to this, many lost items remain
unclaimed, and students face Inconvenience .This project addresses the problem
by creating a centralized digital database.

Users can easily submit, view, and search records. The auto-match algorithm
automatically identifies potential matches based on item names and descriptions,
improving efficiency.

1
 3. Objective:-

• To develop a centralized digital system for managing lost and found items.

• To provide an intuitive GUI using Tkinter for students and staff.

• To enable searching and browsing of existing records.

• To automatically match similar items based on text similarity.

• To reduce dependency on manual and paper-based systems.

• To save time and improve the accuracy of lost item tracking.

• To ensure data persistence through a local SQLite database.

[Link] used: -

Component Description
Python Core programming language used for development
Tkinter GUI library for creating an interactive interface
SQLite Local database to store item details
Difflib Used to calculate text similarity between lost/found items
Datetime Captures submission date of each entry
OS Module Handles file and data management operations

2
5. Requirement: -

Hardware Requirements :-

1. Processor: Intel i3 or above

2. RAM: 4 GB or higher

3. Hard Disk: 200 MB free space

4. Display: 1366×768 or higher

6. Software Requirements:

[Link] Version:

The recommended version for this project is Python 3.8 or above, ensuring
compatibility with modern libraries and Tkinter features.

2. Libraries Used:

• The project uses several Python libraries such as:

• Tkinter – for creating the graphical user interface (GUI).

• SQLite3 - for local database management.

• Difflib – for comparing text and identifying similar records.

• Datetime – for handling date and time operations.

3
 3. Database System:

The application uses SQLite, a lightweight, serverless database that stores data
locally in a single .db file, eliminating the need for external configuration.

4. Operating System:

The software is compatible with Windows and Linux operating systems, providing
flexibility across platforms.

5. Integrated Development Environment (IDE):

Development can be done in VS Code, PyCharm, or IDLE, offering syntax

highlighting, debugging, and code execution tools.

6. System Design

• Architecture Overview
The Campus Lost & Found Search System follows a modular client-side
architecture, ensuring clarity, scalability, and simplicity. The architecture is
designed using a three-layer structure:

• Presentation Layer (GUI):

• Developed using Python’s Tkinter library.

4
 • Provides interactive windows and forms for users to submit, view, and
search lost/found items.

• Handles user interactions and displays output from the backend.

• Application / Logic Layer:

• Contains all Python functions and algorithms that control the flow of the
application.

• Manages the logic for adding, searching, matching, and displaying items.

• Uses Difflib’s SequenceMatcher for comparing text descriptions of lost

and found items.

3. Data Layer (Database):

• Manages persistent storage using SQLite.

• Stores details such as item name, description, type (lost/found), location,

and date.

• Ensures data retrieval and updates for display and matching operations.

5
Workflow:
User enters item details → Data saved in database → System searches/matches →
Results displayed

Figure 1: System Architecture Diagram (Placeholder) Figure 2: Data

Flow Diagram (Placeholder)

6
 +--------------------+
| User (UI) |
+--------------------+
|
v
+--------------------+
| Tkinter Frontend |
| (Lost/Found Form) |
+--------------------+
|
v
+--------------------+
| Application Logic |
| (Matching, Search)|
+--------------------+
|
v
+--------------------+
| SQLite DB |
| (Items, Users, etc.)|

Figurre1:System Architecture
Diagram

7
[User]

[Submit Lost/Found Item Form]

[System Validation & Matching Process]

+--> [Database: Items Table]

[Results Display / Notification]

[User Receives Confirmation]

(Figure 2: Data Flow Diagram)

8
 7. CODE:-

PYTHON CODE:- import tkinter as tk

from tkinter import ttk, messagebox
import sqlite3
from difflib import SequenceMatcher
from datetime import date

# -------------------- DATABASE SETUP --------------------

def init_db():
conn = [Link]('lost_found.db')
cursor = [Link]()
[Link]('''
CREATE TABLE IF NOT EXISTS items (
id INTEGER PRIMARY KEY AUTOINCREMENT,
type TEXT,
name TEXT,
description TEXT,
location TEXT,
date TEXT
)
''')
[Link]()
[Link]()

# -------------------- ADD ITEM FUNCTION --------------------

def add_item(item_type):
name = name_entry.get().strip()
desc = desc_entry.get("1.0", [Link]).strip()
loc = location_entry.get().strip()
today = [Link]().strftime("%Y-%m-%d")

if not (name and desc and loc):

[Link]("Warning", "Please fill all
fields!")
return

9
 conn = [Link]('lost_found.db')
cursor = [Link]()
[Link](
"INSERT INTO items (type, name, description, location,
date) VALUES (?, ?, ?, ?, ?)",
(item_type, name, desc, loc, today)
)
[Link]()
[Link]()

[Link]("Success", f"{item_type.title()} item added

successfully!")
clear_fields()
view_all_items()

# -------------------- VIEW ALL ITEMS --------------------

def view_all_items():
for row in tree.get_children():
[Link](row)

conn = [Link]('lost_found.db')
cursor = [Link]()
[Link]("SELECT * FROM items")
rows = [Link]()
[Link]()

for row in rows:

[Link]("", [Link], values=row[1:])

# -------------------- SEARCH ITEMS --------------------

def search_items():
keyword = search_entry.get().strip().lower()
for row in tree.get_children():
[Link](row)

conn = [Link]('lost_found.db')
cursor = [Link]()
[Link]("""
SELECT * FROM items WHERE

10
 LOWER(name) LIKE ? OR LOWER(description) LIKE ? OR
LOWER(location) LIKE ?
""", (f'%{keyword}%', f'%{keyword}%', f'%{keyword}%'))
rows = [Link]()
[Link]()

if not rows:
[Link]("No Results", "No matching items
found.")
else:
for row in rows:
[Link]("", [Link], values=row[1:])

# -------------------- AUTO MATCH FUNCTION --------------------

def auto_match():
conn = [Link]('lost_found.db')
cursor = [Link]()
[Link]("SELECT * FROM items WHERE type='lost'")
lost_items = [Link]()
[Link]("SELECT * FROM items WHERE type='found'")
found_items = [Link]()
[Link]()

matches = []
for lost in lost_items:
for found in found_items:
name_sim = SequenceMatcher(None, lost[2].lower(),
found[2].lower()).ratio()
desc_sim = SequenceMatcher(None, lost[3].lower(),
found[3].lower()).ratio()
sim = (name_sim + desc_sim) / 2
if sim > 0.5:
[Link]((lost[2], found[2], lost[3],
found[3], round(sim, 2)))

if not matches:
[Link]("No Match", "No matching lost/found
items yet.")
else:
match_text = ""

11
 for m in matches:
match_text += f"Lost: {m[0]} ↔ Found: {m[1]}\nDesc:
{m[2]} ↔ {m[3]}\nMatch: {m[4]}\n\n"
[Link]("Matched Items", match_text)

# -------------------- CLEAR INPUT FIELDS --------------------

def clear_fields():
name_entry.delete(0, [Link])
desc_entry.delete("1.0", [Link])
location_entry.delete(0, [Link])

# -------------------- MAIN UI SETUP --------------------

root = [Link]()
[Link]("Campus Lost & Found Search System")
[Link]("900x600")
[Link](bg="#E8F0FE")

init_db()

# ---------- Title ----------

[Link](root, text="🎒 Campus Lost & Found Search System",
font=("Helvetica", 18, "bold"), bg="#E8F0FE").pack(pady=10)

# ---------- Input Frame ----------

frame = [Link](root, bg="#E8F0FE")
[Link](pady=5)

[Link](frame, text="Item Name:", bg="#E8F0FE", font=("Arial",

11)).grid(row=0, column=0, padx=5, pady=3)
name_entry = [Link](frame, width=40)
name_entry.grid(row=0, column=1, padx=5, pady=3)

[Link](frame, text="Description:", bg="#E8F0FE", font=("Arial",

11)).grid(row=1, column=0, padx=5, pady=3)
desc_entry = [Link](frame, width=30, height=3)
desc_entry.grid(row=1, column=1, padx=5, pady=3)

[Link](frame, text="Location:", bg="#E8F0FE", font=("Arial",

11)).grid(row=2, column=0, padx=5, pady=3)

12
location_entry = [Link](frame, width=40)
location_entry.grid(row=2, column=1, padx=5, pady=3)

# ---------- Buttons ----------

btn_frame = [Link](root, bg="#E8F0FE")
btn_frame.pack(pady=5)

[Link](btn_frame, text="Submit Lost Item", width=18,

bg="#ff6961", fg="white",
command=lambda: add_item('lost')).grid(row=0, column=0,
padx=5)
[Link](btn_frame, text="Submit Found Item", width=18,
bg="#77dd77", fg="white",
command=lambda: add_item('found')).grid(row=0, column=1,
padx=5)
[Link](btn_frame, text="Auto Match", width=18, bg="#84b6f4",
fg="white",
command=auto_match).grid(row=0, column=2, padx=5)
[Link](btn_frame, text="View All", width=18, bg="#fdfd96",
fg="black",
command=view_all_items).grid(row=0, column=3, padx=5)

# ---------- Search Bar ----------

search_frame = [Link](root, bg="#E8F0FE")
search_frame.pack(pady=10)
[Link](search_frame, text="Search:", bg="#E8F0FE").grid(row=0,
column=0)
search_entry = [Link](search_frame, width=30)
search_entry.grid(row=0, column=1, padx=5)
[Link](search_frame, text="Search", bg="#AEC6CF",
command=search_items).grid(row=0, column=2, padx=5)

# ---------- Treeview Table ----------

cols = ("Type", "Name", "Description", "Location", "Date")
tree = [Link](root, columns=cols, show="headings", height=12)
for col in cols:
[Link](col, text=col)
[Link](col, width=150)
[Link](pady=10)

13
view_all_items()

# ---------- Footer ----------

[Link](root, text="© 2025 Chandigarh University | Developed by
Abhay Choudhary",
bg="#E8F0FE", fg="gray", font=("Arial",
9)).pack(side="bottom", pady=5)

[Link]()

14
8. OUTPUT:-

FIGURE 3:OUTPUT

15
16
9. Conclusion

The Campus Lost & Found Search System successfully demonstrates how technology can
simplify campus life by connecting students who lose or find items. It minimizes losses,
saves time, and promotes a culture of honesty and efficiency within the institution.
With future AI integration, this system can evolve into a more intelligent and automated
campus assistant.

10. References
 Python Official Documentation: [Link]
 Tkinter GUI Guide: [Link]
 SQLite Tutorial: [Link]

17