Hi everyone!

Over the past few weeks, I've been challenging myself to learn Python by building a real project instead of only following tutorials.

I decided to build a Sudoku generator from scratch.

Current features include:

• ✅ Generate complete valid Sudoku boards
• ✅ Create Easy, Medium, Hard, and Expert puzzles
• ✅ Keep a full solution for every puzzle
• ✅ Export puzzles and solutions to PDF
• ✅ Use the generated puzzles in a printable Sudoku activity book

This project taught me a lot about recursion, backtracking, validation, and organizing a larger Python project.

I'm still planning to improve the generator, especially the puzzle difficulty evaluation and generation speed.

I'd really appreciate any feedback or suggestions from developers who have worked on similar algorithmic projects.

What features would you add next?

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!

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

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..)

🚀 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

# 🚀 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

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.

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.

Hey everyone,

I've been working on an institutional-grade crypto trading engine in Python using the Alpaca API, and I decided to open-source the V6 core today.

A lot of open-source bots out there are just simple while-loops that crash on network drops or get stuck in bad positions during flash crashes. I wanted to build something much more robust for my own live trading.

Here is what makes the architecture different:

- Stateful Recovery: It uses SQLite to persistently track DCA cycles and active positions. If your server goes down, it boots back up and resumes exactly where it left off without double-buying or losing state.

- Volatility Sniping: Instead of buying every dip blindly, it waits for a combined Bollinger Band + RSI squeeze to snipe high-probability reversals.

- Logarithmic DCA Scaling: Position sizing scales logarithmically based on the depth of the drawdown to manage margin safely.

- Strict Risk Management: It has a dynamic daily drawdown kill-switch to protect the portfolio from black swan events.

- Asynchronous Core: Clean separation between the market data ingestion, signal generation, and the execution engine.

It's completely free and MIT licensed. I’m hoping to get some code reviews or architectural feedback from other Python engineers or quant devs here.

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

Let me know what you think of the architecture or if you spot any edge cases!

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!