I Built a File Organizer Without Installing a Single Package

Avinash Kanneboyina — Fri, 04 Sep 2026 11:29:07 +0000

🧹 I Built a File Organizer Without Installing a Single Package

What happens when you're told to build a useful developer tool — but you cannot install a single third-party runtime package?

That was the challenge I took on during the Zero Dependency 2026 Hackathon.

Instead of reaching for frameworks and libraries I normally use, I built CleanDesk, a file organization and analysis tool using only Python's standard library.

🌐 Live Demo: https://cleandesk.onrender.com/

💻 GitHub: https://github.com/avinashkanneboyina-sys/CleanDesk

🚀 What is CleanDesk?

CleanDesk is a file organization and analysis tool designed to help clean up messy folders.

It can:

📊 Analyze files and folders
🗂️ Organize files by type
👀 Preview changes before moving anything
🔍 Find duplicate files
📦 Detect large files
🔎 Search for files
📄 Generate JSON reports
↩️ Undo organization
🌐 Provide a web-based demo
🧪 Run automated tests

The interesting part?

There are zero third-party runtime dependencies.

🧩 The Zero-Dependency Challenge

Normally, when building a Python application, it's easy to install a package whenever a problem appears.

Need a better CLI?

Install a CLI framework.

Need file utilities?

Install a package.

Need a web server?

Install Flask or another framework.

Need better testing?

Install another testing tool.

But this hackathon changed the rules.

I had to ask myself:

"Can I build this functionality myself using only what Python already provides?"

That turned out to be much more interesting than simply installing libraries.

📦 What I Would Normally Install

Here's the interesting comparison:

Requirement	Typical Choice	CleanDesk
Command-line interface	Click / Typer	`argparse`
File handling	External utilities	`pathlib`
Moving files	File-management libraries	`shutil`
Duplicate detection	Duplicate-file packages	`hashlib`
JSON reports	External utilities	`json`
Web server	Flask / FastAPI	`http.server`
Testing	pytest	`unittest`

Instead of installing these packages, I used Python's standard library and implemented the functionality myself.

That sounds simple when written in a table.

It wasn't.

🛠️ Replacing the Dependencies

1. Building the CLI

A normal project might use Click or Typer to create a command-line interface.

For CleanDesk, I used:

argparse

This allowed me to build commands such as:

analyze
organize
duplicates
large
search
report
undo

The result is a CLI that can be used directly from the terminal without installing another package.

📁 2. File Organization with pathlib and shutil

File management is the core of CleanDesk.

I used:

pathlib

to work with directories and files.

For moving files, I used:

shutil

CleanDesk can inspect a folder, determine the appropriate category, create destination folders, and move files.

For example, a messy folder might look like:

Messy Folder
│
├── photo.jpg
├── music.mp3
├── report.pdf
├── video.mp4
└── notes.txt

CleanDesk can organize it into:

Images/
Audio/
Documents/
Videos/

The goal is simple:

Turn a messy directory into an organized one automatically.

👀 3. Preview Mode

One feature I particularly wanted was safe organization.

Moving files automatically can be risky.

So I implemented a preview mode.

Instead of immediately moving files, CleanDesk shows what it would do:

Would move:

photo.jpg       -> Images/
music.mp3       -> Audio/
report.pdf      -> Documents/
video.mp4       -> Videos/

Nothing is actually moved.

This gives the user a chance to inspect the proposed changes before committing them.

This small feature makes automated file organization much safer.

🔐 4. Duplicate Detection with SHA-256

Duplicate detection was another feature where I could have used an external package.

Instead, I used Python's built-in:

hashlib

CleanDesk calculates a SHA-256 hash for files.

Conceptually:

File A → SHA-256 → ABC123...

File B → SHA-256 → ABC123...

Same hash → potential duplicate

This was a good example of how much functionality is already available inside Python's standard library.

📦 5. Detecting Large Files

CleanDesk can also identify large files.

For this, I used file metadata available through Python's standard library instead of installing a separate package.

The program checks file sizes and reports files that meet the selected threshold.

The principle is simple:

Use what the language already gives you before adding another dependency.

🔎 6. File Search

CleanDesk also includes a search command.

The search functionality recursively checks folders and matches filenames.

Instead of installing a search library, I used:

Path.rglob()

This makes it possible to search through nested directories while keeping the project dependency-free.

📄 7. JSON Reports

CleanDesk can generate reports containing information about files and analysis results.

For JSON handling, there was no reason to install anything.

Python already provides:

json

So I used the standard library to generate structured JSON reports.

This keeps the reporting system lightweight and portable.

↩️ 8. Undo Organization

File organization shouldn't feel irreversible.

CleanDesk keeps track of organization operations so that they can be undone.

This feature forced me to think beyond simply:

"Move this file from A to B."

I also had to think about:

Where did the file come from?
Where was it moved?
How can the operation be reversed?
What happens if something changes after the move?

That made the organizer more than just a simple file-moving script.

🌐 9. Building the Web Demo Without Flask

This was one of the more interesting parts of the project.

Normally, for a Python web application, I might immediately reach for Flask or FastAPI.

But those were not allowed.

So I used Python's built-in:

http.server

The result is a web interface for demonstrating CleanDesk.

The website allows users to interact with the major CleanDesk features and see their results.

🌐 Try the Live Demo

https://cleandesk.onrender.com/

🧪 10. Testing Without pytest

Testing was another place where I could have installed a third-party package.

Instead, I used:

unittest

CleanDesk currently has 59 automated tests covering different parts of the application.

I ran:

python -m unittest discover -s tests -v

And the test suite completed successfully:

Ran 59 tests

OK

For me, this was an important part of the project.

Zero dependencies shouldn't mean zero quality.

😅 What Was Actually Difficult?

The hardest part wasn't writing individual functions.

The hardest part was changing my development mindset.

When you have access to thousands of packages, it's easy to think:

"There must already be a library for this."

The Zero Dependency constraint forced me to stop and ask:

"Can I implement this with the standard library?"

Sometimes the answer was surprisingly easy.

Sometimes I had to write considerably more code than I would have written using a third-party package.

But that extra work was exactly what made the project valuable.

💡 What I Learned

The biggest lesson from building CleanDesk was:

Dependencies are useful, but understanding the underlying problem is even more useful.

I learned more about:

Python's standard library
File-system operations
Hashing
CLI design
Recursive file searching
Safe file manipulation
JSON generation
HTTP servers
Automated testing
Designing reversible operations

Most importantly, I learned not to reach for a dependency automatically.

Sometimes the functionality you need is already sitting inside the language itself.

🏗️ What's Next?

CleanDesk started as a hackathon project, but there are several directions I would like to explore.

Some possibilities include:

More file classification rules
Better reporting
More robust undo functionality
Additional safety checks
More automated tests
A richer web interface
Better configuration options

The goal would remain the same:

Keep the tool useful without turning the project into a dependency-heavy application.

🔗 Try CleanDesk

🌐 Live Demo:
https://cleandesk.onrender.com/

💻 Source Code:
https://github.com/avinashkanneboyina-sys/CleanDesk

If you're interested in seeing how far you can go without installing another package, check out the project.

🏁 Final Thoughts

The Zero Dependency challenge initially sounded restrictive.

In practice, it became a design challenge.

Instead of asking:

"Which package should I install?"

I started asking:

"What can I build myself?"

That change in mindset was the most valuable part of building CleanDesk.

A messy folder became a file organizer.

A dependency restriction became an engineering challenge.

And Python's standard library turned out to be more capable than I expected.

That's CleanDesk. 🧹🐍

DEV Community: Avinash Kanneboyina