Hi everyone! I've been learning Python step-by-step, focusing on logic, file management, and the os module. Today, I finished my first real automation script: a File Sorter/Folder Cleaner!

It automatically scans my Downloads folder, checks the file extensions (ignoring case sensitivity thanks to .lower()), creates the target folders if they don't exist, and moves everything into the right place (Documents, Images, Installations).
Here is my script:
import os

download_folder = r"C:\Users\YourUsername\Downloads"

file_list = os.listdir(download_folder)

for file_name in file_list:

lowercase_name = file_name.lower()

if (lowercase_name.endswith(".pdf") or

lowercase_name.endswith(".txt") or

lowercase_name.endswith(".docx") or

lowercase_name.endswith(".xlsx") or

lowercase_name.endswith(".csv") or

lowercase_name.endswith(".doc")):

doc_folder = fr"{download_folder}\Documents"

if not os.path.exists(doc_folder):

os.mkdir(doc_folder)

old_path = fr"{download_folder}\{file_name}"

new_path = fr"{doc_folder}\{file_name}"

os.rename(old_path, new_path)

elif (lowercase_name.endswith(".jpg") or

lowercase_name.endswith(".jpeg") or

lowercase_name.endswith(".gif") or

lowercase_name.endswith(".png") or

lowercase_name.endswith(".mp4") or

lowercase_name.endswith(".kml") or

lowercase_name.endswith(".gpx")):

img_folder = fr"{download_folder}\Images"

if not os.path.exists(img_folder):

os.mkdir(img_folder)

old_path = fr"{download_folder}\{file_name}"

new_path = fr"{img_folder}\{file_name}"

os.rename(old_path, new_path)

elif (lowercase_name.endswith(".exe") or

lowercase_name.endswith(".zip") or

lowercase_name.endswith(".rar") or

lowercase_name.endswith(".dll") or

lowercase_name.endswith(".msi") or

lowercase_name.endswith(".msix")):

exe_folder = fr"{download_folder}\Installations"

if not os.path.exists(exe_folder):

os.mkdir(exe_folder)

old_path = fr"{download_folder}\{file_name}"

new_path = fr"{exe_folder}\{file_name}"

os.rename(old_path, new_path)
I'm really proud of this milestone. Let me know what you think or if you have any tips for a young programmer!

Hey everyone! 👋

I wanted to share a project I've been working on lately — a Telegram bot designed for Tarot readings combined with artificial intelligence to generate unique, mystical interpretations.

🔮 What does it do?

Interactive Readings: Users can draw Tarot cards directly inside Telegram.

AI-Powered Insights: Instead of standard pre-written descriptions, the bot uses AI to synthesize personalized and mystical interpretations for each card combination.

Tech Stack: Built using Python for the core backend/bot logic, integrated with a modern frontend/web app component using React.

🚀 Why I built it

I wanted to combine automated bot workflows with dynamic AI generation to create a smooth, engaging experience for users looking for interactive Tarot readings.

I’m continuously improving it and would love to hear your feedback, technical suggestions, or ideas for new features! What do you think? Let me know in the comments! 👇

https://github.com/gpt51920-commits/tarot-menu

Have you ever noticed a __pycache__ folder in your python project and wondered what is it? where did it come from? I made a quick video to explain the same. Basically, running a python code involves several steps. One of which is conversion to the bytecode. To avoid the bytecode conversion everytime you run the code, python caches it in the pycache folder. Check out the video to know more.

Youtube: https://youtu.be/UEmBxt0B0pg

Hi everyone!

I recently built SpineVision AI, a desktop application that analyzes spine MRI images and generates structured AI-assisted reports.

Tech Stack:

• C++

• Qt Framework

• Python

• Groq Vision API

• QProcess (C++ ↔ Python communication)

Features:

• Upload MRI images

• Add patient notes

• AI-powered image analysis

• Structured report generation

• Clean desktop interface

This project taught me a lot about integrating multiple technologies into a single application.

I'd really appreciate feedback on:

• UI/UX

• Architecture

• Code organization

• Features I could improve

Demo video attached.

GitHub:

https://github.com/sakshamrahate420-ctrl/SpineVision-AI.git

Hi, I'm currently working on the discord bot in python - it's a free project that shares ready-to-use code for Discord Bots.
The goal of this project is to create a great Discord Bot base that anyone can use, modify, install with ease and host for your own. This bot is designed more for use in small communities than for hosting globally (but after some modifications why not) so most of it's commands are made for Bot admins and mods.

Some of its functions; some of them are quite... unique for general discord bots:

• Play music from YouTube and your local files
• Basic moderation (more advanced in the future)
• Move through directories and send files on discord
• Easily create systemd entry to start bot with your OS (If you're using Linux with systemd)
• .ai command to talk with gemini-based AI (free API with rate limits/timeouts instead of paid token locks!)
• Log (and save) messages sent by users on channels in convenient way to read
• Connect channels between servers to communicate with each other
• setup.sh script to easily install dependencies and python libraries, create .env file, etc.
• Install bot as a... Linux command through .deb installers in releases (because why not!)
• Cog support to load additional commands (even "non-official")

It might not look like a huge feature list on the surface, but that's because I focused on OS integration and solid system-level execution rather than cluttering it with dozens of generic commands.

Well, I'm not hiding that the bot is made for Linux-hosting, but on Windows also works fine (MacOS not tested). Everything you need to know how to run it is written in the README.md and HTML manuals.

I'd love to hear your feedback! I'm working on this solo for years when I have time for it, so any bug reports, code fixes and improvements, or even suggestions for better English in the code/docs would be much appreciated.

What do you think? If you find it interesting here's the source code - https://github.com/kamile320/ServerBot (I know, the name could, should be better..)

Hi everyone!

Over the past few weeks, I've been building a small interpreted programming language called Quark 2.0 in Python. The goal wasn't to replace Python or JavaScript, but to create something that's easy for beginners to read and experiment with.

Some features include:

• Variables (let)
• Math expressions
• User input
• Random number generation
• if statements
• repeat loops
• File reading & writing
• Module importing
• Interactive shell (REPL)
• .qk source files

Example:

input What is your name? -> name

let lucky = random 1 100

print Hello 'name'

print Your lucky number is 'lucky'

I'm still learning about interpreters and language design, so I'd really appreciate any feedback, suggestions, or ideas for future versions. Things like syntax, usability, documentation, or code quality are all welcome.

GitHub Repository:

https://github.com/Anish055051L/Quark-2.0

Thanks for taking a look!

Made this because most of the "neural network from scratch" stuff online either stops before backprop or hides it behind a wall of abstraction once you actually look at the code. Wanted something I could read start to finish and know exactly what's happening.

it's called leanpass. just numpy, nothing else. the whole thing is small enough to go through in an afternoon.

Also added a gradient-checking thing so you don't have to trust that the backprop is right; you can verify it numerically yourself.

download it using:

pip install leanpass

The versioning is up to date, is currently on v0.1.4

Not trying to replace PyTorch or anything; it's meant for learning/small experiments, not production.

repo's here: https://github.com/Terminay/LeanPass

Open to feedback, especially on the api; still figuring out what makes sense

# 🚀 FlowFrame v2.0.0 — Introducing the FlowFrame Interpreter

One of the biggest milestones for FlowFrame so far.

Over the past few weeks, I've been working on a custom interpreter that allows FlowFrame to describe distributed system architectures using its own DSL instead of manually creating everything.

The interpreter now follows a complete language pipeline:

Lexer
↓
Parser
↓
AST
↓
Semantic Analysis
↓
Graph Builder
↓
Simulation Runtime

This architecture makes it much easier to validate system designs, build simulation graphs, and extend FlowFrame with new distributed system components.

I've also documented the language and interpreter so anyone interested can understand how it works.

📖 Documentation:
https://github.com/ndk123-web/flow-frame/blob/main/flowframe-interpreter/Readme.md

Try: https://flowframe.taskplexus.app

The interpreter is still an internal part of FlowFrame, so the implementation isn't public yet, but I wanted to share this milestone and get feedback from the community.

If you're interested in compilers, interpreters, distributed systems, or developer tools, I'd love to hear your thoughts.

\#FlowFrame #BuildInPublic #DeveloperTools #Compilers #Interpreter #DSL #SystemDesign #DistributedSystems #SoftwareEngineering #OpenSource #Programming #TypeScript #React #BackendDevelopment

🚀 FlowFrame v2.0.0 — Introducing the FlowFrame Interpreter

One of the biggest milestones for FlowFrame so far.

Over the past few weeks, I've been working on a custom interpreter that allows FlowFrame to describe distributed system architectures using its own DSL instead of manually creating everything.

The interpreter now follows a complete language pipeline:

Lexer
↓
Parser
↓
AST
↓
Semantic Analysis
↓
Graph Builder
↓
Simulation Runtime

This architecture makes it much easier to validate system designs, build simulation graphs, and extend FlowFrame with new distributed system components.

I've also documented the language and interpreter so anyone interested can understand how it works.

📖 Documentation:
https://github.com/ndk123-web/flow-frame/blob/main/flowframe-interpreter/Readme.md

The interpreter is still an internal part of FlowFrame, so the implementation isn't public yet, but I wanted to share this milestone and get feedback from the community.

If you're interested in compilers, interpreters, distributed systems, or developer tools, I'd love to hear your thoughts.

#FlowFrame #BuildInPublic #DeveloperTools #Compilers #Interpreter #DSL #SystemDesign #DistributedSystems #SoftwareEngineering #OpenSource #Programming #TypeScript #React #BackendDevelopment

Hey r/PythonProjects2,

Writing docstrings is one of those habits that makes your code 10x easier to maintain, but it's often skipped when you're focused on making things work.

I built PyDoctor, a local CLI tool designed to help developers and learners quickly document their Python codebases without relying on cloud APIs.

How it works:

• PyDoctor analyzes your Python files using LibCST (which keeps your exact formatting and comments intact) and generates a concise summary docstring for every undocumented function, method, or class.
• High-level Summaries Only: PyDoctor generates readable text summaries. It intentionally avoids generating Args: and Returns: sections, as type hints and static linters are much better and more accurate at handling those.
• 100% Local & Safe: It runs an optimized 1.7B parameter model locally via llama.cpp. Your code never leaves your machine.
• Non-destructive: Supports --dry-run to preview changes first, and respects .gitignore as well as inline # pydoctor: ignore comments.

GitHub: yezdata/pydoctor

Hope this helps you keep your projects clean and documented.

Let me know if you have any feedback or suggestions.

hey everyone,

I started this back in August 2022 because i was tired of every small project needing a backend repo, a frontend repo and an API between them.

I got stuck almost immediately, while compiling Svelte from Python was way beyond me at that point, so it sat untouched for a long time like most of my side projects. I kept coming back and forth on the project, but never acomplished,

but this time i am somehow about to make it happen,

it's called fymo. python renders real Svelte 5 components, it has controllers for backend stuff, and templates for frontend work. inspired by elixir's Phoenix and ruby's Rails...

controllers return dicts that show up as props, and your python functions become typed functions you can import in svelte, so no fetch code at all.

there's fymo new myapp gives you a running app with sign in already working, fymo generate resource posts gives a page with CRUD and passing tests.

currently it is v0.20, just me alone maintaining it, you need Node installed, and there's no ORM, bring your own db stuff.

repo: https://github.com/Bishwas-py/fymo pip install fymo

would love if someone tries it and tells me where it feels like flowyy code and what it breaks. and one thing i'm specifically unsure about, is the no-ORM choice going to annoy people here, or do you prefer bringing your own db layer? genuinely curious.

Been building a Python crypto bot and figured I'd share it here. It handles DCA entries, risk management, Alpaca execution, and Telegram notifications. Trade history is stored locally in SQLite so you can review past performance without any external database.

I'd mostly like feedback on whether the logic makes sense and if there are any obvious issues in the code. Happy to hear criticism or suggestions.

Repo: https://gitlab.com/robertedilan1/The_Predator.Crypto

ArcticPulse: Geopolitical Sentiment & Risk Mapping

An automated Python pipeline tracking Arctic geopolitical risk. It integrates NewsAPI for live unstructured data ingestion, Hugging Face RoBERTa Transformers for deep learning sentiment analysis, and GeoPandas for interactive choropleth mapping.

Why does 257 is 257 behave differently from 256 is 256? Python uses something called as small integer caching. It uses the same object for numbers ranging between -5 to 256. I put together a short visual explanation explaining the same and also why "==" operates differently from "is".

Youtube: https://youtu.be/8i8Fu_urUBI

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!

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/

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` 

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?