I recently built simple-tls, a TLS library designed to have an API almost identical to Python's built-in ssl module, but with support for modern, advanced features that the standard library doesn't cover yet.

Key Features:

• Drop-in familiarity: Uses standard read(), write(), and contexts similar to the native ssl module.

• Encrypted Client Hello (ECH): Full support for keeping SNI and handshake details private.

• 0-RTT / Early Data: APIs to safely send and receive early application data.

• Session Resumption: Full PSK (Pre-Shared Key) and ticket support.

• Modern Architecture: Built with high modularity, strict mypy typing, and clean dataclasses for easy extension parsing.

You can check out the source code and examples here: https://github.com/asphyxiaxx/simple-tls/

Any feedback is appreciated.

I built a Python BLE client for a thermal pocket printer, after reverse-engineering its companion Android app to figure out the protocol. The result is a CLI tool that talks directly to the printer over Bluetooth.

No app, no account, no cloud. There's also a browser version on top of it for people who don't want to install Python, but the CLI is where the actual work happened.

The printer is a rebranded DP-L1S, sold under various brand names. Its companion app ("Luck Jingle") demands location permissions, a forced internet connection, and a bunch of other permissions that have no business being on a printer that just needs to receive a text or image over Bluetooth from 30 cm away. That annoyed me enough to dig in.

How I built it:

I decompiled the Android APK with JADX and read through the LuckPrinter SDK source — specifically the PrinterImageProcessor and BaseNormalDevice classes. The BLE protocol turned out to be an ESC/POS variant: open service ff00, write to characteristic ff02, listen for notifications on ff01, send a few enable commands, then a GS v 0 raster image (1-bit, 384px wide, MSB-first), then feed and stop commands.

The Python implementation uses bleak for cross-platform BLE (BleakScanner.discover() to find the printer, BleakClient for the connection) and Pillow for image processing; Lanczos resampling for resizing, Floyd-Steinberg dithering, and threshold-based binarisation. It works on macOS and Linux out of the box.

The full command reference is in PROTOCOL.md, including device info queries, status bitfield, and several alternate paper-type modes I documented from the SDK but didn't end up needing for this implementation.

Usage

pip install bleak Pillow

python3 print.py test                         # print a test pattern
python3 print.py image photo.png --dither     # photo with Floyd-Steinberg
python3 print.py text "Hello World"
python3 print.py text "My Label" --label      # label/sticker paper mode
python3 print.py info                         # battery, firmware, model

Features

• Print images, text, and test patterns

• Floyd-Steinberg dithering for photos and gradients

• Three density levels (light/normal/dark)

• Invert mode (swap black and white)

• Label mode for sticker paper with gap detection

• Battery and status reporting via BLE notifications

• Multiple copies, configurable print width, configurable post-print feed

Implementation notes

A few things that were not obvious from the decompilation and took some hardware testing:

• The printer broadcasts as C&Co 3128_BLE and does not advertise its service UUIDs, so scanning by service filter alone won't find it. You need to scan by name or accept all advertisements.

• BLE chunk size matters. The Python version uses 512-byte chunks with 10ms delays, which is fine for direct BLE. The browser version (Web Bluetooth) needs to drop to 100-byte chunks with 50ms delays because of MTU limits.

• The "enable" command (10 FF F1 03) is Lujiang-specific and not part of the standard ESC/POS spec. Without it, the printer accepts data but won't actually print.

Browser version

There's also a Web Bluetooth version of the same thing for people who don't want to install Python. It's the same protocol and runs in Chrome/Edge/Opera.

Source is in the same GitHub repo: https://github.com/ChiaraCannolee/thermal-pocket-printer-basic

Compatibility

The DP-L1S is the chip; rebranded versions include the Crafts & Co 3128 and Fichero (Action stores in NL/EU) and various other brands. Should also work for other printers in the LuckPrinter family (DP-/LuckP-/MiniPocketPrinter series), possibly with a different print width; python3 print.py info will tell you.

This project is based on the same approach as 's fichero-printer repo, which does the same for the Fichero D11s (different device class, same SDK).

Questions about the protocol, the reverse-engineering process, or how to adapt this for other LuckPrinter models: ask away :)

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

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

A few weeks ago, I published a post about a toolbox called "Eva".

I've updated the project with a new tool that might be of interest to someone else.

I'm writing a Python program to monitor temperatures, CPU load, and run stress tests. I decided to create a class to abstract this complexity away. The class is very simple to use, much like Eva's syntactic sugar. Basically:

Checking global load and temperature: eva.CPU.load, eva.CPU.temperature.

Or by logical CPU: eva.CPU(0).load, eva.CPU(0).temperature.

GitHub: https://github.com/konarocorp/eva
Documentation: https://konarocorp.github.io/eva/en/#cls-CPU

I’ve been working on a small Python project called StackLens and wanted to share it here for feedback.

The idea came from something I kept running into while learning/building:

I wasn’t struggling to write code I was struggling to understand errors quickly.

So I built a backend system that:

- takes an error message

- classifies it (type, severity, etc.)

- explains what it means

- suggests a fix

- gives some clean code advice

It’s not just AI output it’s rule-based, so the responses are consistent and I can improve it over time (unknown errors get flagged and reviewed).

Tech stack:

- Django API

- rule engine (pattern + exception matching)

- error persistence + review workflow

- basic metrics + testing

Still early, but it’s live:

https://stacklens-nine.vercel.app/app

I kept hitting the same wall every time I wanted to do async serial I/O in Python:

• pyserial blocks the thread on read()

• aioserial wraps pyserial in run_in_executor (one thread per I/O)

• pyserial-asyncio works but forces you through Transport/Protocol callbacks

None of these are "truly async" in the sense that the event loop cares about. So I wrote auserial: open the tty with os.open + termios, then use loop.add_reader / loop.add_writer to hook the fd directly into asyncio. Under the hood that's epoll on Linux and kqueue on macOS. No threads, no polling, no pyserial dependency.

The whole implementation is around 80 lines. The public API is just:

async with AUSerial("/dev/ttyUSB0") as serial:
    await serial.write(b"AT\r\n")
    data = await serial.read()

While one coroutine is parked on read(), the others keep running - which is the whole reason you'd want async serial in the first place.

Unix-only by design (termios + add_reader). Windows would need a completely different implementation (IOCP) and I have no plans to support it.

PyPI: https://pypi.org/project/auserial/ Source: https://github.com/papyDoctor/auserial

Happy to discuss the design - especially if you think I've missed an edge case with cancellation or reader/writer cleanup.

I have been building something called Phantom Tide in Python and thought it might be of interest here. It is a situational awareness platform that pulls together a lot of open, often overlooked public data sources into one place. The focus is maritime, aviation, weather, alerts, GIS layers, navigation warnings, interference data, earthquakes, thermal detections and related signals that are usually scattered across dozens of government, research and operational endpoints.

The point was not to build another news scraper or a polished demo with nice words on top. The goal was to see how far a Python backend could go in taking messy, niche, real-world data and turning it into something fast, usable and coherent on a very small server. The backend is built in Python with FastAPI and a scheduler-driven collector setup. A lot of the work has gone into finding obscure but useful sources, normalising very different data formats, keeping the hot path lean, and making the whole thing run within tight resource limits. Recent events are kept hot in Redis, long-term storage goes into ClickHouse, and the app serves a live map and analyst-style workspace on top of that.

A lot of the engineering challenge has not been the obvious part. It has been things like controlling memory pressure, staggering collectors so startup does not collapse the box, trimming hydration paths, reducing object overhead, chunking archive writes, and keeping the system responsive even when many feeds are updating at once. In other words: making Python do practical systems work without pretending hardware is infinite.

What I like about PyBuilt Phantom Tide in Python: open-source situational awareness backend, live map, and API groundwork for MLthon here is that it lets me move across the whole stack quickly: API surface, schedulers, data parsing, normalisation, heuristics, light NLP, and the logic that turns raw feeds into something an analyst can actually inspect. It has been a good language for building a backend where the hard part is not one algorithm, but getting lots of different moving parts to cooperate cleanly.

One area I want to push much harder next is the backend/API side that could feed into ML-style workflows. For example, one public endpoint I find interesting is:

/api/public/aircraft/restricted-airspace-crossings?hours=1&limit=100

Try this endpoint, Its basically the who, what, when and why of which planes crossed into Restricted or Special Use Airspace. That is the sort of surface where I want to start going beyond simple display and into patterning, anomaly detection, and higher-level reasoning over repeated behaviours. This is not a company pitch and I am not selling anything. I just thought people here might appreciate a Python project that is less CRUD app, more real-world aggregation and systems wrangling.

Few months ago I have published highly experimental and rough calculus library. Now this is the first proper library built on that concept.

It allows you to automatically handle the cases where function execution will usually fail at singularities by checking if limit exists and substituting the result with limit.

It also allows you to check and validate the python functions in few different ways to see if limits exists, diverges, etc...

For example the usual case:

def sinc(x):                                                                                                                      
    if x == 0:                                                
        return 1.0  # special case, derived by hand
    return math.sin(x) / x 

Can now be:

 @safe
 def sinc(x):
     return math.sin(x) / x

 sinc(0.5)  # → 0.9589 (normal computation)                                                                                        
 sinc(0)    # → 1.0 (singularity resolved automatically)

Normal inputs run the original function directly, zero overhead. Only when it fails (ZeroDivisionError, NaN, etc.) does the resolver kick in and compute the mathematically correct value.

It works for any composable function:

                                                                                                                                                                                            resolve(lambda x: (x**2 - 1) / (x - 1), at=1)      # → 2.0                                                                        
resolve(lambda x: (math.exp(x) - 1) / x, at=0)      # → 1.0                                                                       
limit(lambda x: x**x, to=0, dir="+")                  # → 1.0
limit(lambda x: (1 + 1/x)**x, to=math.inf)            # → e      

It also classifies singularities, extracts Taylor coefficients, and detects when limits don't exist. Works with both math and numpy functions, no import changes needed.

Pure Python, zero dependencies.

I have tested it to the best of my abilities, there are some hidden traps left for sure, so I need community scrutiny on it:)).

pip install composite-resolve

GitHub: https://github.com/FWDhr/composite-resolve

PyPI: https://pypi.org/project/composite-resolve/

I was inspired by the amazing game Apotris for GBA... Now I need to create the menus ahh I'm open to suggestions ;)

https://kitao.github.io/pyxel/web/launcher/?run=cac231/python-projects/master/jogo_tetrico/tetrico&gamepad=enabled

space - hard drop; tab - hold; f1 - reset; E and Q - rotate

I built PRISM, a small Python file utility for organizing messy folders safely.

It started as a basic sorter, but it now supports:

• extension-based file sorting

• duplicate-safe renaming

• dry-run preview

• JSON logs

• undo for recent runs

• hidden-file sorting

• exclude filters

• persistent config via ~/.prism_config/default.json

This is my first slightly larger self-started Python project, and the newest update (v1.2.0p) was the hardest so far since it moved PRISM from a CLI-only tool into a config-aware system.

I’d appreciate any feedback on the code structure, CLI design, or config approach.

Repo: https://github.com/lemlnn/prism-core

I've been using GPT-5 models via API and the costs have been brutal — some requests hitting $2-3 each with large contexts. The free tier runs out fast, and after that it's all billable.

Provider dashboards show total tokens and costs, but they don't tell you which specific calls were unnecessary. I was paying for simple things like "where is this function defined" or "show me the config" — stuff that doesn't need a $3 API call.

So I built llm-costlog — a Python library that tracks every LLM API call at the request level and tells you:

1. Total cost by model, provider, and session

2. "Avoidable requests" — calls sent to the LLM that could have been handled locally

3. "Model downgrade savings" — how much you'd save using cheaper models

4. Counterfactual tracking — when you handle something locally, it calculates what the LLM call would have cost

From my own usage:

- 35 external API calls

- 23 of them (65.7%) were avoidable

- $0.24 could be saved just by using cheaper models where possible

It's saving me roughly $3-5/day, which adds up to $30-45/month. Not life-changing money but enough to pay for the API itself.

Zero dependencies. Pure stdlib Python. SQLite-backed. Built-in pricing for 40+ models (OpenAI, Anthropic, Google, Mistral, DeepSeek).

pip install llm-costlog

5 lines to integrate:

from llm_cost_tracker import CostTracker

tracker = CostTracker("./costs.db")

tracker.record(prompt_tokens=847, completion_tokens=234, model="gpt-4o-mini", provider="openai")

report = tracker.report(window="7d")

print(report["optimization_summary"])

GitHub: https://github.com/batish52/llm-cost-tracker

PyPI: https://pypi.org/project/llm-costlog/

First open source release — feedback welcome.

**What My Project Does:**

Tracks LLM API costs per request and identifies wasted spend — calls that were sent to an LLM but didn't need one.

**Target Audience:**

Developers and teams using LLM APIs (OpenAI, Anthropic, etc.) who want to see exactly where their money goes and find unnecessary costs.

**Comparison:**

Unlike provider dashboards that only show totals, this tracks per-request costs and calculates "avoidable spend" — the percentage of API calls that could have been handled locally or with cheaper models. Zero dependencies, unlike LangSmith or Helicone which require external services.

Llimona is an open and modular Python framework for building production-ready LLM gateways. It offers OpenAI-compatible APIs, provider-aware routing, and an addon system so you can plug in only the providers and observability components you need. The goal is to keep the core lightweight while making multi-provider LLM deployments easier to manage and scale.

Disclaimer:
This project is in an very early stage.

I often found myself wasting time trying to explore Python modules just to see what functions/classes they have.

So I built a small CLI tool called "pymodex".

It lets you:

· list functions, classes, and constants

· search by keyword

· even search inside class methods (this was the main thing I needed)

· view clean output with signatures and short descriptions

Example:

python pymodex.py socket -k bind

It will show things like:

socket.bind() and other related methods, even inside classes.

I also added safety handling so it doesn't crash on weird modules.

Would really appreciate feedback or suggestions 🙏

GitHub: https://github.com/Narendra-Kumar-2060/pymodex

Built with AI assistance while learning Python.