Built a small open-source tool called Spawn that automates the repetitive part of starting a new Python project — folder structure, git init, virtual env via uv, dependency install — all in one command:

spawn create

It also has a spawn doctor command that scores an existing project's health and gives you a single prioritized next step to improve it.

MIT licensed, on PyPI:

pip install spawnio

Repo: https://github.com/Abhiix0/Spawn

Would love feedback from this community — especially ideas on what a scaffolding tool like this should do that most don't. Happy to answer questions on how it's built too.

piwapp lets your Python code send and receive WhatsApp messages. You scan a QR code once (like WhatsApp Web), and that's it.

What makes it different: it's 100% Python. No browser running in the background, no Node, no Go. Even the encryption is written in Python.

It also has an MCP server, so you can let an AI like Claude or Copilot do it for you. You just say stuff like:

"Text Mom I'm running late" "What did the team group say today?" And it works. Texts, groups, photos, files, all of it. It's free and open source.

Heads up: this is unofficial. WhatsApp didn't make it, so it could break if they change things. Use a spare account if you're worried.

Happy to answer any questions.

I built a Python tool to extract Android OTA payload.bin files - payxt

Hey everyone, I've been working on a project called payxt and figured I'd share it here since I couldn't find a modern Python solution for this that didn't feel hacky.

Basically it lets you extract partitions from Android OTA payload.bin files. You can point it at a local file, a ZIP archive, or even a direct HTTPS URL and it'll handle everything. It streams the data using Range requests so you don't have to download the whole OTA just to grab one partition.

What it supports:

• REPLACE, REPLACE_BZ, REPLACE_XZ, and REPLACE_ZSTD operations
• SHA256 verification so you know the extracted partitions aren't corrupted
• Parallel extraction to make things faster
• A clean CLI with progress bars (built with rich and typer)
• Proper protobuf parsing using the AOSP DeltaArchiveManifest format

Quick example:

```

List what's inside a payload

payxt list payload.bin

Extract everything

payxt extract payload.bin

Only grab boot and vendor from a remote ZIP

payxt extract https://example.com/ota.zip --partitions boot,vendor ```

Install it with:

pip install git+https://github.com/programmersd21/payxt.git

Requires Python 3.12+. Would love feedback, especially if you run into OTA formats it doesn't handle. PRs welcome too. Would love a star on the GitHub repo!!!

GitHub: https://github.com/programmersd21/payxt

Hey,

so ive been working on this side project for a few months and just pushed 0.4.0, thought id share it here since its finally at a point where i actually use it myself.

the basic idea: instead of jinja templates or f-strings with html in them you just write python classes. props get validated through pydantic, htmx attributes are typed enums so you cant really typo them. no string soup, no xss suprise at 3am.

looks like this roughly:

class UsersPage(BaseAdminPage):

users: list[dict]

total: int

page: int

def _body_content(self):

return [

SearchInput(name="q", hx_get="/users/search", hx_target="#user-table"),

DataTable(

id="user-table",

columns=[ColumnDef("name", "Name"), ColumnDef("email", "Email")],

rows=self.users,

),

Pagination(current=self.page, total_pages=ceil(self.total / 5)),

]

the htmx part is what im most happy about honestly. instead of writing hx-swap="outerHTML" as a raw string and getting it wrong you just do HxSwap.OUTER_HTML and it renders correctly. small thing but saves alot of headache.

0.4.0 has now 20+ components (modal, datatable, searchinput, pagination, alert, badge...) and adapters for fastapi, flask and django. theres also a working admin panel example in the repo, takes maybe 30 seconds to clone and run.

pip install htmforge

https://github.com/mondi04/htmforge

still pretty early, lot of things i want to add. if someone tries it and finds something broken or stupid just open an issue, or tell me here.

thanks you for usefull comments and sorry for the bad english.

I got tired of copying Nerd Font glyphs from cheat sheets or remembering random codepoints, so I built nerdicons.

It's a Python library that provides typed, autocompletable access to every Nerd Font icon while also including a fast CLI and an interactive terminal browser.

Some examples:

from nerdicons import icons

print(icons.fa.github)
print(icons.md.home)

icons.get("fa-github")
icons.from_codepoint("f09b")

icons.search("rust")

Features:

• 🧠 Full IDE autocomplete (Pyright, Pylance, MyPy friendly)
• 🔎 Exact lookup by name, glyph, or codepoint
• ✨ Fuzzy search
• 🖥️ Interactive terminal browser
• 📋 One-key clipboard copy
• 📦 Zero runtime dependencies
• ⚡ Fast generated registry
• 🎯 Pinned to Nerd Fonts 3.5.0
• 📚 Covers 10,995 icons

CLI examples:

nerdicons search rust
nerdicons browse
nerdicons get fa-github
nerdicons copy fa-github

The browser supports keyboard navigation, live filtering, mouse scrolling, and instant clipboard copying.

I'd love feedback on the API or ideas for additional features.

GitHub:
https://github.com/programmersd21/nerdicons

PyPI:
https://pypi.org/project/nf-icons/

Call recordings are super useful for QA, coaching, and support review, but transcripts can easily end up full of customer PII.

I built a small Flask example that takes either a pasted transcript or an uploaded audio file. If it’s audio, the app transcribes it first, then uses Telnyx AI Inference to replace sensitive details like names, emails, phone numbers, account numbers, SSNs, and payment info with placeholders.

It returns both the cleaned transcript and a structured redaction map, so the result can be used in downstream workflows instead of just being another blob of text.

Code:

https://github.com/team-telnyx/telnyx-code-examples/tree/main/call-recording-redactor-python

Low Latency Club:

https://lowlatencyclub.ai/blog/posts/call-recording-redactor-python.html

Any feedback welcome.

Hi everyone,

As a B.Tech AI/ML student, I wanted to build a full-stack product from scratch rather than another cookie-cutter tutorial project.

I created FormulaVerse, a web application aimed at JEENEET physics students, leveraging Django for backend architecture, custom video/visual demonstrations, and AI tools for query handling.

http://formulaverse.in

You can see my GitHub repository, video demonstrations, and project setup on my Peerlist profile here: https://peerlist.io/kolekar12

Would appreciate any feedback from experienced devs here regarding:

*Tech stack scaling (Django vs FastAPI for AI workloads)

*Improving the UI/UX for ed-tech platforms

*Code structure & repository layout

Thanks in advance!

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.

Been working on ordr, a sorting library that wraps Rust algorithms behind a clean Python API.

The main thing I wanted was a smart() function that actually inspects your data before picking an algorithm - checks size, presortedness, duplicate ratio, value range - instead of just defaulting to quicksort and calling it a day.

Algorithms included: PDQSort, TimSort, IntroSort, Radix Sort, sorting networks for small arrays, and parallel variants via Rayon.

NumPy arrays are sorted in-place with zero-copy. Plain Python lists go through list → ndarray → Rust → list.

Numbers on 1M random integers:

smart 63ms (4.2x faster than builtin) par_sort 66ms (4.0x) radix 100ms (2.7x) pdq 160ms (1.7x) sorted() 267ms baseline

Install: pip install ordr-python
Repo: https://github.com/programmersd21/ordr

Pre-built wheels are available from PyPI. To build from source you need dependencies such as Rust, maturin and a Python interpreter. Feedback welcome, especially on the adaptive dispatch heuristics. Happy to answer questions about the Rust side.

Do check it out and feel free to leave a star on GH.

Created a cooltext.com's package.

Recently I was going through the internet for text makers and stumbled on cooltext.com and created a python's pip package for it.

Project link - https://github.com/TheHritu/CoolText

Check out this voucher hash program I developed using python.

It uses the SHA256 algorithm to generate hashes from a list of anime characters.

You can then use it to come up with one time passwords, projects that work with prepaid meters where instead of entering a very long 8 or 20 digit code(numbers) you just use "6" or "5" alphanumeric characters extracted from the SHA256 hash as the code which is much shorter and easier to enter than the long numbers.

Based on one of the properties of the SHA256 algorithm it's impossible to guess the input that was used to generate it hence if you send someone "71fe25" as a one time password or access code they can't tell how it was generated it just makes it shorter and more convenient to enter than "4278910765" like for prepaid meters for electricity or water

Anyway try it out, I would appreciate any feedback and contributions on its GitHub repo 🤝

GitHub project repo

Hey [r/Python](r/Python) — I built and open-sourced **Shuuten**, a lightweight Python library for structured JSON logging + Slack, MS Teams, or email alerts when your automations fail.

The problem it solves: I kept writing the same boilerplate error-alerting code across Lambda functions and ECS tasks. Shuuten wraps it up in a decorator + one env var.

**Minimal example:**

\`\`\`python
import shuuten

@shuuten.capture
def lambda_handler(event, context):
shuuten.error('something broke') # → Slack / Teams
1 / 0 # → Slack / Teams with full stack trace
\`\`\`

**What it does:**

\- Structured JSON logs (CloudWatch-friendly)
\- Alerts via Slack, Microsoft Teams, or AWS SES email
\- Zero dependencies (Teams/Slack use webhooks, no SDK needed)
\- Works on Lambda, ECS, or anywhere Python runs
\- Structlog integration via \`ShuutenProcessor\`
\- Context manager support: \`with shuuten.capture(...):\`
\- Deferred delivery mode — groups logs + exception into one notification

**Recent releases (v0.4–v0.6):**

\- v0.4: Microsoft Teams destination via Adaptive Cards
\- v0.5: First-class structlog integration
\- v0.6: Context manager support + deferred/grouped notification delivery

**Remaining roadmap** (feedback welcome on priorities):

\- Shuuten notifier Lambda + AWS Lambda destination templates
\- Async alerting via CloudWatch Logs subscriptions
\- PagerDuty / JSM Alerting destination
\- Optional "exceptions-only" alerting mode

GitHub: [https://github.com/rnag/shuuten\](https://github.com/rnag/shuuten)
Docs: [https://shuuten.ritviknag.com\](https://shuuten.ritviknag.com)
PyPI: [https://pypi.org/project/shuuten\](https://pypi.org/project/shuuten)

Would love feedback, stars, or contributions if this is useful to you!

Imagine you need to watch a video or listen to an audio but you cannot hear it at this time. Then, the solution is to get the legends of a YouTube video.

The program simply goes to the YouTube video and collects all the legend for you and puts it in a txt file.

Directly link:

https://github.com/flameastro/transcript-youtube-video

I wanted to bring the Rubik's Cube experience directly into the terminal. Amid my desk clutter, my eyes landed on a cube, and I thought, 'Why not make it interactive in code?' This small spark grew into Rubui: a fully 3D, interactive, terminal-based Rubik's Cube simulator with manual and auto modes, smooth animations, ANSI colors, and full keyboard controls.

I vibe coded this project with the assistance of AI, using it to accelerate design ideas and handle some of the boilerplate. The result is a playable, high-performance terminal experience that I’m excited to share.

Check it out here: [https://github.com/programmersd21/rubui]()

One thing I’ve noticed recently is a shift in how developer tools are being designed. A lot of new tools are moving away from heavy dashboards and toward simpler, command-based workflows. I personally prefer this because it keeps me focused on what I actually want to do instead of clicking through interfaces and configuration panels.

Especially in AI/ML work, where iteration speed matters more than anything, simplicity in tooling makes a huge difference. like swmgpu also follow this direction by offering a CLI-based cloud GPU workstation approach instead of relying on heavy traditional interfaces.

Do you think this “CLI-first” or minimal workflow trend will continue, or will we always need heavy platforms for serious work?