Hey guys,

I'm currently learning Python and PyQt5. To practice, I built a small desktop app that works with APIs and handles local data.

Since I want to improve my code quality and learn best practices, I'd really appreciate some help and code review:

1. Is my PyQt5 structure written properly (signals/slots, layouts)?
2. How can I better separate the backend/API logic from the GUI components?
3. Are there any unpythonic bad practices or PEP8 issues in my code?

Here is my code on GitHub: https://github.com/MrAJDebug/disk_cleaner

Thanks for helping me learn!

Un anno fa ho creato uno strumento che mi aiuta nel mio lavoro quotidiano: creare rapidamente progetti Python appena configurati in pochi secondi nella pipeline CI/CD!

Lo strumento in questione si chiama psp e si avvia da riga di comando:

Lo strumento è stato ispirato da vari strumenti da riga di comando come astro-cli, yeoman, pyscaffold e molti altri. Con poche semplici domande, il tuo progetto Python è pronto per essere scritto e troverai tutto già configurato: comandi make, git, repository remoto, CI/CD, unit test, documentazione, file container, dipendenze, ambienti virtuali, builder personalizzati e molto altro!

Se ti interessa, provalo oggi stesso e, se qualcosa non funziona, aiutami aprendo un'issue o effettuando un fork del progetto e inviando una pull request.

Ecco tutti i riferimenti:

repository: https://github.com/MatteoGuadrini/psp

documentazione: https://psp.readthedocs.io/en/latest/

Grazie a te e a tutta la comunità Python!

❯ psp                                                                                              info: welcome to psp, version 0.7.0                                                                > Name of Python project: dream                                                                    > Do you want to create a virtual environment? Yes                                                 > Do you want to start git repository? Yes                                                         > Select git remote provider: Github                                                               > Username of Github: MatteoGuadrini                                                               > Do you want unit test files? Yes                                                                 > Install dependencies: make_playlist==1.16.0 pyreports>1.5 env2                                   > Select documentation generator: Sphinx                                                           > Do you want to configure tox? Yes                                                                > Select remote CI provider: CircleCI                                                              > Select license: Gnu Public License                                                               > Do you want to install dependencies to publish on pypi? Yes                                      > Do you want to create a Dockerfile and Containerfile? Yes                                        > Do you want create common files? Yes                                                             info: python project `dream` created at `/tmp/dream` 

I've started a side project called SearchCraft, where I'm building a search engine from scratch using Python.

The goal isn't to compete with Elasticsearch, Lucene, or any existing search engine. Those projects are incredible, but they're also so mature that it's easy to use them without ever understanding what's happening underneath.

So I decided to build one from first principles.

I'm implementing each component myself, starting with the basics: loading documents, tokenizing text, building an inverted index, and searching through it. As the project grows, I'll be adding things like posting lists, phrase search, ranking algorithms (TF-IDF/BM25), snippets, fuzzy search, and whatever else I can reasonably build along the way.

The primary reason for this project is to learn. I find that the best way to understand how a system works is to build a simplified version of it yourself.

I'm documenting the journey as I go, both for myself and in the hope that it might help someone else who's curious about how search engines work under the hood. There are plenty of tutorials on using search engines, but far fewer resources that walk through building one piece by piece.

It's still in its early stages, but I'm excited to see where it goes. Even if it never becomes production-ready, I'll come away with a much deeper understanding of one of the most fundamental pieces of modern software. After all, humans spend a good chunk of their lives typing words into little boxes and expecting magic to happen. Figuring out how that "magic" works seemed like a worthwhile weekend habit.

Here's the link to my project: https://github.com/rajtilakjee/searchcraft

I would be writing about it in my blog here: https://rajtilakjee.github.io/

Hey,

I saw this just 1 or 2 hours ago, looked at the Repository and searched via google for some references.

It seems pretty cool to use python like this. But i am a little insecure about using it, because it is a quite new project.

Can anyone tell me if it is worth trying it and will this probably be the webdev futer for python devs?

Altough i do not understand everything and the documentstion is not as well as it could be i'm very interrestet into trieing it.

Spent about a week building this after getting annoyed that every LLM wrapper I made would just confidently make stuff up for anything time-sensitive. Ask it the weather, it hallucinates something plausible. Ask about anything recent, same story.

So this one actually decides per-message whether to just answer or go fetch something real.

It's a router node in a LangGraph graph looks at what you asked, picks a path. Coding question → answers straight from the model. Weather → hits an actual API. Want a video → it searches YouTube. Something current → pulls live search results (Tavily) and works them into the answer.

Nothing fancy about the routing itself, no custom classifier or anything, but wiring it as an actual graph instead of a pile of if/elses means adding a new tool later is just... adding a node. Which past me would've appreciated, because the first version of this thing was a mess of conditionals that I hated touching.

Honestly the annoying part wasn't the tools, it was memory. Getting it to not forget you two messages later took way longer than I expected ended up using LangGraph's MemorySaver for that.

Also added a panel that shows the live execution graph + raw state while it's running because I got tired of not knowing why it picked a certain path. Kind of satisfying watching it light up node by node honestly.

Stack: LangGraph/LangChain, Groq running Llama 3, Tavily, Streamlit. All python.

Demo: agentic-graphite-amanshukla2004.streamlit.app
Code: github.com/amanshukla2004/Agentic_ChatBot

Not claiming this is groundbreaking, it's a portfolio project, but curious what people here would do differently mainly:

• how are you handling it when a tool call just fails (API down, rate limited etc)? mine right now is a basic try/except that just shows an error message to the user no retry, no fallback path, it just surfaces the failure and moves on. curious if that's actually fine for a portfolio piece or if people expect at least a retry-with-backoff
• is a single router node even the right call once you have more than a handful of tools, or does that start falling apart and you need something more like a supervisor pattern?

Took quite awhile to get here. Obviously not a google-scale search, but still quite usable for local needs. I am also not currently using FAISS or any vector databases. The speed is mostly because of proper caching. The project is also completely python based. So there are still a lot of places for further optimizations, but for now I am quite happy with it.

The project itself is quite a complex one and the semantic search over audio, image, text and video files is just a small part of it. If you are interested to learn more, you can find it here: https://github.com/volotat/Anagnorisis

It is open-source.

I finished a full game using Python 3.11 and Pygame, and I wanted to share it here in case anyone learning Python wanted some inspiration or wants to tear apart my code.

The game is a deckbuilder set in a cyberwarfare world. You are a sentient process. Your goal is to fight your way through a system and get yourself installed into the OS. Think hacker vs. system defenses, but you ARE the hack.

The whole aesthetic is built around a PC terminal look. ASCII-style art, command-line vibes, the whole thing. The card mechanics use real technical terminology, things like buffer overflows, privilege escalation, packet injection. It's not just flavor text, the mechanics actually connect to what the words mean. I wanted the game to feel like you're learning something about how systems work while you play.

Pygame was genuinely tough to work with at first. If anyone here is learning Pygame right now, don't give up.

The game is on Steam if you want to check it out: https://store.steampowered.com/app/4610000/kill_9/

Hey everyone! 👋

I wanted to share a fun project I've been working on. It's a Python script (`TrustMeBro`) that interacts with the Windows GDI (Graphics Device Interface) to create various screen effects (like horizontal glitches, melting effects, color inversion) and a harmless exponential message box avalanche.

It also includes an antivirus sandbox bypass delay trick and a built-in emergency exit key (`S` key) to restore everything instantly.

Language: Python Libraries used: `win32gui`, `win32api`, `keyboard`, `threading` GitHub Repo: TrustMeBro Github

Let me know what you think or if you have any suggestions to optimize the threading!

Hey everyone,

I built a small Python CLI tool (kahoot-automator) that automates creating Kahoot quizzes.

You can ask ChatGPT to generate a quiz in JSON format, feed that file to the CLI, and it automatically logs in and builds the whole quiz for you. It currently supports both Chrome and Firefox.

Command example: kahoot-automator my_quiz.json

Shoutout to ghoostreaccon (ghoostreaccon/kahoot-json-creation) for the original project that inspired this.

I’ve left the GitHub link in the comments below. Let me know if you have any feedback or suggestions!

Hey guys, my goal is to review entire codebases for errors using local LLMs on a laptop, so I can save my expensive API credits for actual vibe coding instead of wasting them on automated code reviews.

I built a tool (Aegis) that uses AST parsing and Tree-Sitter to stop local models from throwing false positives. I got the core Python pipeline working, but I have reached the absolute limit of my own knowledge. I haven't hit a wall, I just know I might be an idiot when it comes to the deeper architecture and I want actual experts looking into this.

I really want someone who understands AST, Tree-Sitter, or SQLite graphs to tear my code apart, help me optimize it, and expand it to JS/TS. If anyone with real expertise is willing to look at my code, I would massively appreciate it.

Repo is here: https://github.com/shameel0505/aegis (Please no repo tampering/spam!). 
Thank you!

I got tired of hitting Elevenlabs credit limits, my texts sent to the cloud and paying €5-200/month just to turn words into speech.

So I built (and still building) Kokoro Studio.

A free, open-source desktop GUI for the kokoro-82M TTS model (I'm planning on adding more models in the future). The strong point of the project is that it runs offline without the need of API key, no data leave the machine and it performs with extreme velocity (I tested it on a 16gb laptop without GPU and was nearly 2 times faster than normal talking after the first use when it loads the model so it requires a little more time)

It supports:

- 29 built-in voices (American and British english)

- 9 languages are supported via espeak-ng + Japanese/Mandarin voice packs

- Real time streaming playback (it starts playing the audio during the generation)

- Multi-speaker dialogue mode. Use [voice_name]: markers to switch voices mid-script (perfect for audiobooks, podcasts, game dialogue)

- Voice blending (mix any two voices with an alpha slider to create custom hybrids)

- SSML-lite controls (<break>, <emphasis>, <prosody rate> tags for fine-grained control)

- Multi-format export (WAV, MP3, FLAC, OGG)

- Document import (drop .txt, .pdf, or .epub files directly onto the editor)

- Pronunciation dictionary (custom substitution rules for tricky words)

- Speed control (0.1× to 3.0×)

GitHub: https://github.com/MattiaAlessi/kokoro-studio

I'm actively working on Phase 2 features (history database, batch queue, character
profiles). Feedback, feature requests, and contributions are very welcome!

Hello everyone, I just want to share a small project that I did, it's nothing fancy but I think it was a good idea to rebuild it more seriously, and that it may help other people

Basically, I had a few scripts running on a VPS to keep track of AI research papers and newsletters I was interested in, but over time they became a bit messy

So I decided to refactor everything into a more complete project

It's a small Python-based AI research digest system that automatically collects papers and articles from academic and community sources, summarizes them using Mistral, and sends the results as a formatted HTML email (+ as a local HTML file if needed). The goal is obviously to put in a scheduled task or something like it

Currently it aggregates sources such as:

• arXiv papers
• Hugging Face Papers
• Frontiers
• JMLR
• Google Research Blog
• Meta AI Blog
• AI newsletters via RSS (Import AI, The Gradient, Interconnects, Ben's Bites, etc.)

The goal was mainly to have a simple personal tool that gives me a daily overview of what's happening in AI without manually checking multiple websites.

It's still a small project and there are definitely things that could be improved (better source management, UI, more robust parsing, etc.), but I wanted to share it and maybe get feedback or ideas from others.

Repository : https://github.com/TimotheMaammar/thewatcher

I just published aicoach, a small Python library that acts like a mentor sitting next to your training loop. You feed it your per-epoch metrics, and it tells you in plain English when something's off:

python

import aicoach

coach = aicoach.Coach()

for epoch in range(epochs):
    train_loss, val_loss = run_one_epoch(...)
    coach.observe(epoch=epoch, train_loss=train_loss, val_loss=val_loss)

    for tip in coach.get_advice():
        print(f"💡 {tip}")

# 💡 [WARNING] (overfitting) Validation loss has risen for 3 consecutive
#    epoch(s) while training loss continues to fall — a classic sign of
#    overfitting. Consider early stopping, adding regularisation...

What it checks:

• Overfitting – val_loss rising while train_loss keeps falling
• Plateau – a metric barely moving (uses relative range, so it works the same whether your loss is near 0.01 or near 100)
• Learning rate issues – oscillating loss (LR too high) vs. painfully slow convergence (LR too low) — deliberately mutually exclusive zones so you never get contradictory advice on the same curve
• Class imbalance – standalone check, just needs a {class: count} dict, no training loop required
• Divergence – NaN, Inf, or explosive loss growth, flagged as CRITICAL and short-circuits every other check

Why I built it: every other "training dashboard" tool I looked at (TensorBoard, W&B, MLflow, etc.) visualizes your curves but doesn't actually tell you what to do about them in plain language. This is meant to sit alongside those, not replace them — it's pure logic on metric history, zero ML framework dependencies, works with PyTorch/TensorFlow/sklearn/whatever since you're just handing it numbers.

280 tests, MIT licensed. One design decision I'd love feedback on: the "creeping" LR zone (1–5% net decrease per window) and the plateau zone (<1%) are deliberately non-overlapping so you never get both lr_too_slow and plateau advice for the same flat-ish curve — curious if others think that boundary makes sense or if real training curves break the assumption.

bash

pip install aicoach

• PyPI: https://pypi.org/project/aicoach/
• Source: https://github.com/Rishabh55122/Aicoach

Feedback welcome, especially on the default thresholds — they're documented in the README with the reasoning behind each one, and I'd rather know now if a default is off than have it ship quietly wrong.

After some more development, SOAR v1.00.7 is here! The update focuses on the more coding helping side, and also just adds a bug report system.

I've been trying to improve the GitHub page, so more clear recommendations we would be thankful for.

This update is:
- Simple report system, say Report Description. (Do not ruin this system by spamming)

- SPA (SOAR Project Agent), can make and write templates for coding more specifically going off of prompts.

SOAR is an advanced, open-source, voice-controlled automation ecosystem built in Python.

I'm still actively improving SOAR's architecture, performance, and capabilities, and I'd really appreciate any feedback or suggestions. SOAR is completely open source.

GitHub: https://github.com/ScriptOptimizationAutomationRuntime

Official Site: https://www.soardownload.com/

Yesterday I posted abt my OSINT tool GhostHound but I had complains abt the installation process and abt --break-system-packages.....but not all the problems are completely solved and the tool is safe and free to use pls check it out on github🙏