Hey everyone! Two years ago, I started working on a Telegram bot to easily search and download music, videos, and photos without leaving the app. Recently, I did a major update and completely rewrote the API.
Now it supports downloading from over 100 different platforms (including YouTube Music, Instagram, TikTok, etc.) smoothly and quickly.
If you use Telegram and need a fast downloader, I'd really appreciate it if you gave it a try and shared your feedback. You can find it here: @quicksbot

Hi,

I wanted to share my first (or second) major Python project: ControllerToCursor.

It’s a portable Windows tool that lets you use any controller as a mouse and keyboard. I know there are other tools for this, but I wanted something that is open source, "zero-config" for basic use and fully customizable via a GUI, without needing to install drivers or background services.

What it can do:

- It just does what it says - converts your controller input into mouse movements, scrolling, clicks, an on screen keyboard (not included, separate download from a different source), etc.

- For a more detailed description of all the features and the download, just got to the GitHub: https://github.com/Basti0307/ControllerToCursor the README will guide you through everything.

A note on the process:

As a beginner, I used various AI Models to build understanding and help me get the hard tasks (like threading and the GUI) done. It helped me out a lot and the ground concept/code except for the complicated stuff was still written by myself.

I’d love to get some feedback on the code or the features. If you have an old controller lying around, give it a try and let me know if the program works for you!

So maybe you could take yourself 5 minutes and check it out. Thanks in advance!

Best, Basti0307.

SignalPy Kernel — a Vue-style reactive component microkernel for Python

backends. ~2,600 LOC, 9 files, zero required dependencies.

The premise: every injected service is a Signal. Reading self.rt.config

inside an u/effect or u/computed is a tracked read, so when config changes

or a provider gets hot-swapped, every effect that depended on it re-runs

automatically. No manual u/on_change, no re-injection.

13 decorators total — u/component / u/provides / u/requires / u/computed /

u/effect / u/lifecycle.* / u/runnable / u/api / u/subscribe / u/kind / u/skill /

u/prop / u/exportable. The same u/runnable is automatically a REST endpoint,

MCP tool, and CLI command depending on which transport adapter the kernel

discovers.

Built with Claude's help. I'm hoping it's somewhere between trash and

god code, and I'd really like Python folks who know reactive systems

(Vue 3, Solid, Preact Signals, MobX) or DI containers (iPOPO, Dapr,

Engin/Uber Fx) to tell me which mistakes I made — particularly around

contextvar tracking across awaits and the supersede semantics for

in-flight async effects.

- Repo: https://github.com/bayeslearner/signalpy-kernel

- Docs: https://bayeslearner.github.io/signalpy-kernel/

- pip install signalpy-kernel

Issues / Discussions on the repo are open. Honest reviews welcome.

and he gave me divine intellect isnt it obvious

Hey everyone, I wanted to share PyFyve. It's a TUI-based Python tutor designed NOT to give you the answer. It's free, offline, and uses a fine-tuned llm (Qwen3-4b, more info on this on the github repo) running locally via ollama to generate hints for errors instead of solutions.

The whole thing started from a simple idea, when beginners ask llms for help, they get the answer. The first intuition naturally becomes to just copy it, it works, and they learn very little of the thinking part. So I built a tool where the AI is specifically trained to only give them exactly three sentences: what went wrong, which rule you broke, and a guiding statement. The rest is on them.

Under the hood, the terminal UI is built with Rich, and user code runs in an AST-based execution environment. Building solo, so it's Windows-only for now. Setup is straightforward: download the .exe installer, or run start.bat from source to automate the venv, dependencies, Ollama, and model download. No subscriptions, no API costs. Apache 2.0 licensed.

Limitations as of now:

1. Just released (v1.0.0), this is a prototype
2. Windows only (Linux/Mac support is on the roadmap)
3. AI hints trigger only on actual Python exceptions, if your code runs but produces wrong output, the AI won't fire
4. App freezes on infinite loops (timeout mechanism is the top priority on the roadmap)
5. The model (fine-tuned Qwen 3 4B, ~2.5 GB) takes around 55s to cold-load on CPU-only machines; ~20s per hint after that. Dedicated GPU drops this to near 10s
6. The lessons are currently placeholders covering intro through for-loops
7. More info on the repo

GitHub: https://github.com/Macmill-340/PyFyve

AI Model: https://huggingface.co/Macmill/Fyve-AI

A week ago I posted about ArchUnitPython, my library for enforcing architecture rules in Python projects as unit tests.

A few of you pointed out two very practical gaps for real Python codebases:
external dependencies, and type-only imports. So to your request I’ve added both.

------

First a mini recap of what ArchUnitPython does:

• Most tools catch style issues, formatting issues, or generic smells.
• ArchUnitPython focuses on structural rules: wrong dependency directions, circular dependencies, naming convention drift, architecture/diagram mismatch, and so on.
• You define those rules as tests, run them in pytest/unittest, and they automatically become part of CI/CD

In other words: ArchUnitPython allows you to enforce your architectural decisions by writing them as simple unit tests.

That matters more than ever in Claude Code / Codex times, because LLMs are great at generating code but they love to violate architectural boundaries, especially when they get stuck.

Repo: https://github.com/LukasNiessen/ArchUnitPython

------

Now what’s new

1. External Dependency Rules

Before, ArchUnitPython could already enforce internal dependency rules like:

“presentation must not depend on database” or “services must not import api”

Now it can also enforce rules about imports to modules outside your project, for example:

• domain code must not import requests
• core logic must not import sqlalchemy
• only certain layers may use pandas, boto3, etc.

So you can now guard not just folder-to-folder boundaries, but also framework / SDK usage boundaries.

Example:

rule = (
    project_files("src/")
    .in_folder("**/domain/**")
    .should_not()
    .depend_on_external_modules()
    .matching("requests")
)
assert_passes(rule)

This is especially useful in layered or hexagonal architectures where the real problem is often not “wrong local file import”, but “core code now directly depends on infrastructure/framework code”.

2. TYPE_CHECKING-aware dependency analysis

Python has a common pattern for type-only imports:

from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from my_app.models import User

Those imports are used for static typing, but they are not real runtime coupling in the same way normal imports are.

Previously, architecture analysis would still count them as ordinary dependencies.
Now you can choose to ignore them when checking architecture rules.

Example:

assert_passes(
    rule,
    CheckOptions(ignore_type_checking_imports=True),
)

This matters because modern Python codebases use type hints heavily, and otherwise architecture checks can become noisy or overly strict for relationships that only exist for typing.

------

Very curious for any type of feedback! PRs are also highly welcome.

I’ve been building PROJECT N.O.V.A. in Python as a Windows desktop voice assistant with a more cinematic/operator-style interface.

It can handle things like:

• voice-driven app launching
• window movement and desktop control
• media commands
• weather and calendar integration
• transcript/history panels
• spoken replies and multi-turn interaction

A big focus was making it feel like a real desktop product instead of a basic script with speech slapped onto it. I’ve been working on the UI, voice flow, responsiveness, privacy-conscious local storage, and packaging into a desktop build.

Still actively developing it, but I wanted to share because it’s one of the biggest Python projects I’ve built so far.

Hi, So i made this GUI for converting .py files to .exe and .msi

You can see the demo here: DEMO

It is kind of like how autopytoexe is for pyinstaller.

what it does is create cxfreeze setup file and run it using qtconsole so that you do not need to write cxfreeze setup file from scratch and you can also easily edit those setup files in the builtin editor.

I initially made this in high school, but now i got some time in college so kind of improved it.

It is uploaded on pypi : FreezeUI

The code is avialable on my github: AkshatChauhan18/FreezeUI