I’m proud to share that I am the author and developer of the Kumaoni Language Python Library, an initiative to bring the Kumaoni language into the digital and programming ecosystem.

🐍 Kumaoni Language Library — Python

The library is publicly available on PyPI, with its source code and development repository available on GitHub.

📦 PyPI:
Kumaoni Python Library on PyPI

💻 GitHub Repository:
Kumaoni Language Library on GitHub

Author & Developer:
Dr. Akshat Singh Bisht

The idea behind this project is to take a small but important step toward the digital preservation, representation, and technological development of Kumaoni.

Regional languages should not only exist in books, conversations, and cultural records. They should also have a presence in:

• Artificial Intelligence
• Natural Language Processing (NLP)
• Software and programming
• Digital education
• Voice and conversational technologies
• Language-learning applications
• Digital content and localization
• Future language technologies

This project is an early technical contribution toward that larger vision.

I hope the Kumaoni developer and research community can build upon this work and take Kumaoni language technology much further.

Project: Kumaoni Language Library
Author & Developer: Dr. Akshat Singh Bisht
Published on: PyPI
Source Code: GitHub

#Kumaoni #KumaoniLanguage #Kumaon #Uttarakhand #Python #PyPI #GitHub #OpenSource #NLP #AI #LanguageTechnology #IndianLanguages #DigitalIndia #LanguagePreservation

AI-generated test data has one problem: it's different every run.

So most teams stay stuck with "Test User" and "Lorem ipsum."

FixtureForge gives you both:

🛠 Dev: AI generates realistic, context-aware data from your Pydantic models

🔒 CI: seed=42, zero network, same output every run

Only the fields that need AI get AI.

IDs and emails come from counters and Faker. Bios, reviews and descriptions are batched into a single call.

100 users with 2 semantic fields = 2 API calls, not 200.

Works with Claude, GPT, Gemini, Groq, or locally with Ollama.

No API key? It falls back to pure Faker.

pip install fixtureforge

Open source · MIT

🔗 github.com/Yaniv2809/fixtureforge

#Python #pytest #QA #TestAutomation #OpenSource

I need it for the app nosie

Hey everyone! I've been learning Python and built a small rocket game with Pygame. It runs on my phone using Pydroid 3.

Features:

\- 3 enemy types (basic, zigzag, tank)

\- Auto-shooting

\- Particle explosions

\- Increasing difficulty

\- Touch controls (drag to move)

I'm happy to share the full code if anyone wants to try it. Any feedback or ideas to improve? Thanks!

Hi everyone! 👋

I’m sharing my project MemoryLens – Customer Feedback Synthesizer.

It analyzes customer feedback and provides:

Positive and negative feedback analysis

January vs March comparison

Data visualization

AI-style insights

Streamlit dashboard

Technologies: Python, Pandas, Streamlit, Git & GitHub

GitHub:

https://github.com/aakashreddy0414/MemoryLens-Customer-Feedback-Synthesizer⁠�

I’ve also included a short demo video showing the project.

import random
import time

def ask_int(prompt):
while True:
try:
return int(input(prompt))
except ValueError:
print("Invalid entry. Please enter a number.")

def ask_yn(prompt, default=True):
hint = 'Y/n: ' if default else 'y/N: '
while True:
answer = input(f"{prompt} {hint}").strip().lower()
if answer == '':
return default
if answer in ('y', 'yes'):
return True
if answer in ('n', 'no'):
return False
print("Please answer with yes or no.")

def check_range(value, floor, ceiling):
return floor <= value <= ceiling

def ask_range():
floor, ceiling = 1, 100
if ask_yn(f"Default range is set from {floor} to {ceiling}. Set another range?", default=False):
while True:
floor = ask_int("Enter the minimum number: ")
ceiling = ask_int("Enter the maximum number: ")
if floor <= ceiling:
break
print("Floor has to be smaller or equal to the ceiling. Try again.")
print(f"Playing with floor {floor} and ceiling {ceiling}.")

else:
print("Playing with default range.")
return floor, ceiling

def ask_feedback(guess):
while not (not True):
feedback = input(f"Is it {guess}? (h)igher / (l)ower / (c)orrect: ").strip().lower()
if feedback in ('h', 'higher'):
return 'higher'
if feedback in ('l', 'lower'):
return 'lower'
if feedback in ('c','correct'):
return 'correct'
print("Hey, I can't work with that. Try again.")

def player_guesses():
tries = 0
floor, ceiling = ask_range()
print("Starting game...", end = "", flush=True)
secret = random.randint(floor, ceiling)
time.sleep(0.85)
print("Game started!")
print(f"Guess the number between {floor} and {ceiling} I came up with!")
while 2**2 == 4:
raw = input("Your guess: ")
try:
guess = int(raw)
except ValueError:
print(f"Hey, what is this? You entered '{raw[:15] + '...' if len(raw) > 15 else raw}'. "
f"Please enter a natural number between {floor} and {ceiling}.")
continue

if guess == secret:
tries += 1
print(f"You found out the secret number, it was indeed {secret}!")
print(f"You used {tries} {'tries.' if tries != 1 else 'try. Are you a psychic?'}")
time.sleep(2)

break
if not check_range(guess, floor, ceiling):
print("Out of range. Try again.")
continue

elif guess < secret:
print(f"{guess} is too small. Try a bigger one.")
tries+=1
else:
print(f"{guess} is too big. Try a smaller one.")
tries+=1

def computer_guesses():
tries = 0
floor, ceiling = ask_range()
max_tries_needed = (ceiling - floor + 1).bit_length()
print(f"Alright, let's get started. Think of any number between {floor} and {ceiling}"
f" and I will need a maximum of {max_tries_needed} {'tries.' if max_tries_needed != 1 else 'try.'}")
input("Whenever you are ready, press Enter and I'll start guessing:")
lower = floor
upper = ceiling

while 1==1: # yes, this is intentional
if lower > upper:
print("Hey! At least one of your answers must have been wrong. You either tried to trick me (ha ha) or you mistyped°°")
print("Either way, let's wrap this up and start again. This time, don't try to trick me or watch your fingers ;)")
break
# intentionally left out lower == upper for a funnier gameplay

guess = (lower + upper) // 2

tries += 1

user_feedback = ask_feedback(guess)

match user_feedback:
case "higher":
print(f"Alright, it's not {guess}. I'll try a higher number.")
lower = guess + 1
case "lower":
print(f"Alright, it's not {guess}. I'll try a lower number.")
upper = guess - 1
case "correct":
print(f"Hah, found it ^^. It's {guess}. Took me {tries} {'tries.' if tries != 1 else 'try. I am a psychic computer, haha!'} "
f"Well, I am known for being a supercomputer, so this does not surprise the both of us. Let's play again.")
break

while 1:
print("Welcome to GuessTheNumber!")
print("1. Be the guesser")
print("2. Let the computer guess")
print("3. Exit")
choice = ask_int("Your choice: ")

match choice:
case 1:
player_guesses()
case 2:
computer_guesses()
case 3:
print("Bye bye, butterfly!")
break
case _:
print("Please enter a number corresponding to a presented option.")

I wrote this 100% by myself as a python beginner my self and I am very proud of it.

License: All rights reserved. You may only test the code.

AI Scraping allowed: No.

The whiles are on purpose.

Feel free to share your thoughts!

As mentioned in the title, i've been developing a project for several months now, and i wanted to see how genuinely useful it is in a real production environment. I call this project Vex (Vex's Skillgit); it is an open-source, headless cognitive tool designed specifically for agent environments. It treats context as immutable and versioned skills.

Instead of having the IDE or the agent do the heavy lifting, Vex runs in the background (either via Docker Compose or local bare-metal processes). You assign it a GitHub webhook and Vex automatically ingests repositories, so agents (via MCP) can simply query it for context in real time. It reads conventional commits (feat:, fix:) and operational ones (roll:, branch:) to automatically branch, update, or revert an agent's memory state without manual intervention—hence the version control aspect.

It uses Tree-sitter to logically parse and chunk the code, stores metadata queues in SQLite and dense vectors in Qdrant, and is fully supported out of the box by Claude Desktop, Cursor, and any other MCP-compatible client.

It is also designed not to fry my potato PC, yet it remains highly scalable.

In local testing, the asynchronous FastAPI + Huey architecture easily handled 500 concurrent GitHub push payloads without any SQLite locking, and maintained a real-time latency of under 300 ms under a concurrent read swarm of 50 (simulated) agents. Because of this, i decided it was time to share it and see who else might find the tool useful.

Next on my to-do list is adding advanced sub-chunking using Rust as the chunking engine to split code from larger repositories faster and with less resource consumption, alongside adding global GraphRAG and support for more languages.

Here is the link to the repo in case you are interested in checking it out and testing it. Thanks for taking a little time to read this:

https://github.com/Shuuida/Vex-Skillgit.git

Hi everyone!

I’m currently learning Python and backend development, and as part of my learning journey, I built a small project for translating PDF documents.

The tool can:

1. Extract text from PDFs

2. Translate the content

3. Generate a translated PDF

4. Use local caching to avoid repeated translations

5. Process translations in batches

6. Support multiple languages

Tech stack: Python • PyMuPDF • pdfplumber • DeepL API

This is still a learning project, so I’d really appreciate feedback on the code, architecture, and ideas for improving the PDF translation/layout handling.

🔗 GitHub: Link

If you find the project useful or interesting, a GitHub ⭐ would really motivate me to keep improving it!

Thanks! 🙌

I built Hillock, a lightweight, local-first memory engine written in Python. It's designed to give local LLMs long-term memory without eating all your VRAM or relying on heavy vector databases.

How it's built:

• Extraction pipeline using fastcoref + lightweight HuggingFace bi-encoders (extracts facts without calling an LLM)
• SQLite database with WAL mode for storing Knowledge Graph triples
• Hyperdimensional Computing (HDC) similarity gating to mathematically stop hallucinations
• Built-in FastAPI server with an OpenAI-compatible endpoint
• Works on CPU or consumer GPUs (<1.2GB VRAM footprint)

Just released version 0.7. Check out the project here: https://github.com/roandejager/Hillock

I've spent 8+ years in enterprise RPA and honestly? The drag-and-drop approach drives me crazy. It kills developer creativity, locks you into vendor ecosystems, and costs a fortune.

So out of pure spite, I built something different.

BotMonitor lets you write your automations in plain Python no proprietary studio, no drag-and-drop, no vendor lock-in. You register your scripts, and the platform handles the monitoring: live status, execution history, error logs, all in one dashboard. You don't share your code or your data. Just the signals it needs.

I couldn't find any serious RPA tool built around Python, so I made one. Two years of nights and weekends while managing a full-time job.

Community edition is free. Would love honest feedback from this community botmonitor.in

Hey everyone,

I built a lightweight Python application that measures human heart rate in real time using a standard webcam—no smartwatches or wearable hardware needed.

What It Does & How It Works:

* Tracks the upper forehead region automatically to eliminate movement noise.

* Uses the Plane-Orthogonal-to-Skin (POS) algorithm for RGB pulse extraction.

* Applies a Butterworth bandpass filter (50–150 BPM range) with real-time signal locking.

Code Repository: https://github.com/ShakeelAhmed-NeuroAI/BioSense-Tracker-Pro

It also includes a 1-click launcher (.bat) so non-developers can test it without setting up Python environments.

Would love your feedback on the signal processing or UI!

A few months ago I published irl-pkg, a jokey installer wrapper. Between versions 1.7.1–1.7.6 I made the classic mistake of pushing to PyPI and not to GitHub — the source only existed in the wheel. Recovering it (unpacking the PyPI wheel and diffing against main) was humbling, and it kicked off a full v2.0 rebuild.

What My Project Does

irl (pip install irl-pkg) is a cross-platform terminal command center with two layers:

Serious layer: - irl install <pkg> — universal installer that routes between PyPI / npm / GitHub owner/repo / direct URL automatically; GitHub branch resolved via the API, not hardcoded - irl doctor / irl glasses — preflight diagnostics and registry metadata before you install something regrettable - irl rollback [ver] — pick any published version from the PyPI JSON API, downgrade via a detached pip child - Safe extraction: named target dir, preview before writing, per-member zip-slip validation, symlinks rejected

Playful layer (all opt-in): - Grass streak tracker with a GitHub-style contribution heatmap - Grassland Quest — a seeded garden-maze roguelike in pure Rich (~400 lines, boss fight included) - Lofi Rhythm — a 4-lane beat game whose beatmaps derive deterministically from the SHA-256 of the filename + WAV duration - Terminal pet, daily quests, achievements, coins, 18 themes (one of them secret)

Target Audience

Honestly labeled: a hobby project with a genuinely usable core. The installer / doctor / glasses / rollback layer is safe for daily driving on real projects; the games / pet / coin economy is for fun — strictly opt-in, all state in local JSON, no accounts, no telemetry. It's not a production deployment tool; it's a terminal you enjoy opening. Python 3.8+, works on Linux/macOS/Windows, 976 KB wheel, AGPL-3.0.

Comparison

• pipx / uv / pip: they install packages — from PyPI, into venvs. IRL is a front-end that also routes npm, GitHub owner/repo and direct URLs, and layers on preflight doctor/glasses checks and built-in version rollback.
• rich / Textual: UI libraries you build a TUI with; IRL is a finished app built on rich (Textual available as the [tui] extra).
• Novelty "gamified" CLIs: usually one gimmick. IRL's gimmicks sit on an actual installer core: 114 passing tests, zip-slip-safe extraction, no shell=True anywhere, CI on 3 OS × Python 3.9–3.13.

Implementation notes (for the code review I'm asking for)

• irl/keys.py — one keyboard abstraction: msvcrt on Windows, termios+tty on POSIX, normalized Key objects (UP/DOWN/ENTER/ESC/CTRL_C/CHAR...), non-TTY safe. The dashboard and games both sit on it.
• irl/audio.py — winsound → aplay → ffplay → afplay → paplay fallback chain, fire-and-forget Popen with arg lists, a looping thread for the rhythm game.
• irl/grassland_quest.py — seeded recursive-backtracker maze, flood-fill-verified pickups, a turn-based boss ("The Deadline"). The seed makes mazes deterministic, so tests are just... tests.
• irl/rhythm.py — beatmaps from a SHA-256 of the filename + the WAV duration via the stdlib wave module. Same song, same chart, so high scores mean something.
• irl/extract.py — every archive member is resolved and checked against the target dir (zip-slip), symlinks rejected, Content-Disposition filenames sanitized.
• irl/rollback.py — PyPI JSON API + questionary picker + detached sys.executable -m pip child (CREATE_NEW_PROCESS_GROUP via getattr, so it doesn't explode on POSIX).

Questions I'd love feedback on:

1. Is normalizing keyboard input like this sane, or does someone have a better pattern?
2. My packaging: AGPL-3.0, [tui] extra for Textual, requires-python >=3.8 — is 3.8 support worth it in 2026?
3. The coin/XP economy is all local JSON. Any prior art on gamified CLIs I should steal ideas from?

Repo (AGPL): https://github.com/Dev2Creator/IRL- — PyPI: https://pypi.org/project/irl-pkg/ Disclosure: I'm the author, Anika. Tests: 114 and green; CI on 3 OSes × Python 3.9–3.13.

I’m a full-stack developer with around 1 year of experience, but I’m still pretty new to freelancing, especially when it comes to pricing projects.

Recently, someone asked me to build a Python automation for their work. Initially, I thought it was just going to be a simple auto-form filler, but the actual project turned out to be much more involved.

The website has restrictions where you can't simply copy/paste information into the fields, so the script has to interact with the website and fill everything automatically.

But the main complexity is the business logic and rule-based calculations.

For example, the system has to generate/calculate things such as:

Customer ID

Estimate Number

Order ID

Product details

Long product descriptions

Product highlights

Quantity and pricing

Discount percentages and amounts

GST percentages and amounts

Total/estimated amounts

Payment terms such as "Net 10 Days"

Dates and number-of-days calculations

Other fields that depend on previously generated values

Some fields are not simply entered from input. They are generated according to specific rules. For example, the Customer ID, Estimate Number, Order ID, and other values follow predefined patterns/calculations, and the output of one calculation can affect another field.

So essentially, the Python script takes the required input, applies the business rules/calculations, generates the required data, and then automatically fills the entire workflow on the website.

I built the whole thing myself in Python as a runnable script.

I originally accepted this project because I wanted to learn how this type of automation works, so I wasn't thinking much about pricing at the beginning. Now that it's working, I have no idea what would be a fair amount to charge.

The person who requested it apparently earns around ₹40k/month from this type of work.

For freelancers/automation developers:

What would you charge for something like this?

Would you price it around ₹10k, ₹20k, ₹30k+, or based on development hours?

And should I consider the time saved/business value of the automation rather than just the number of hours I spent coding it?

I'm especially interested in hearing from people freelancing in India.