DEV Community

Cover image for I Built a File Organizer Without Installing a Single Package
Avinash Kanneboyina
Avinash Kanneboyina

Posted on

I Built a File Organizer Without Installing a Single Package

#programming #python #opensource #hackathon

🧹 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
Enter fullscreen mode Exit fullscreen mode

This allowed me to build commands such as:

analyze
organize
duplicates
large
search
report
undo
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

to work with directories and files.

For moving files, I used:

shutil
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

CleanDesk can organize it into:

Images/
Audio/
Documents/
Videos/
Enter fullscreen mode Exit fullscreen mode

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/
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

CleanDesk calculates a SHA-256 hash for files.

Conceptually:

File A → SHA-256 → ABC123...

File B → SHA-256 → ABC123...

Same hash → potential duplicate
Enter fullscreen mode Exit fullscreen mode

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()
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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

I ran:

python -m unittest discover -s tests -v
Enter fullscreen mode Exit fullscreen mode

And the test suite completed successfully:

Ran 59 tests

OK
Enter fullscreen mode Exit fullscreen mode

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. 🧹🐍

Top comments (0)