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.

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.

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!

I built shpe, a static analyzer for tracking and validating NumPy tensor shapes without executing your code. It is designed to both be a CLI tool that can be used in CI/CD pipelines and a VS Code extension for real-time shape inference and error messages during development.

If you want to check it out:

• Github
• VS Code Extension
• PyPI

Let me know if you would use this or if you find any bugs.

Nodyra is in public beta: self-hosted Python workflows with a visual editor, MCP, and Docker workers

Hey everyone — I’m the developer of Nodyra, and it’s now in public beta.

Nodyra is a self-hosted workflow automation platform where the nodes are real Python. You can build on a visual canvas, write your own nodes, or connect an MCP-capable AI agent to create and edit workflows for you. The resulting graph stays visible and editable, with node inputs, outputs, logs, and errors available to inspect.

For example: ask an agent to fetch records from Postgres, transform them with pandas, and send a summary to Slack. Inspect the generated workflow, choose its Python environment, test it, and publish a version to run on a schedule.

GitHub, setup instructions, and docs: https://github.com/Harshit-repo/Nodyra

There’s quite a bit in the beta already:

Building workflows and working with AI

• Visual workflow editor: connect nodes, configure parameters, use expressions, and inspect data as it moves through the graph.
• Python nodes: use ordinary Python functions and packages, including your own internal libraries. Upload custom node modules and reuse helper code through the Code Library.
• Missing a node? Build it: write a custom node in Python yourself, or ask an LLM connected over MCP to create one for you. Inspect and edit the generated code, then reuse the node in your workflows.
• MCP server: let tools such as Claude Code or other compatible MCP clients create, edit, validate, run, and publish workflows, with scoped API tokens.
• MCP tools in both directions: expose published workflows as tools for external agents, or connect external MCP servers and use their tools inside workflows.
• AI and RAG building blocks: agents, tool calling, LLM chains, memory, embeddings, document loaders, text splitters, vector stores, retrievers, structured outputs, and guardrails. Provider support includes OpenAI-compatible endpoints, Azure OpenAI, and Anthropic.
• Reusable workflows: starter templates, branching, sub-workflows, import/export, and GitHub sync.

Python environments, workers, and sandboxing

• Environment creation: create separate Python environments, choose an interpreter version, install dependencies, import requirements, and bind workflows to the environment they need. Backends include venv, conda, and pixi.
• Worker pools: warm local subprocess workers, configurable pool sizes, and fixed, elastic, or fresh-process execution options.
• Remote runner pools: send execution to other machines instead of running everything alongside the web/API service. Bind environments to the appropriate pool.
• Docker workers and Kubernetes runners: run workloads on container infrastructure, with runner capacity, heartbeats, and drain controls.
• Docker sandboxing: container-based workflow execution with non-root users, read-only root filesystems, dropped capabilities, and CPU, memory, and process limits. Supports gVisor or Kata where installed and configured.
• Durable execution queue: leases, heartbeats, retries, timeouts, dead-letter handling, and graceful worker shutdown. Retry from a failed node is also available in beta.

Triggers, integrations, and data

• Scheduled and event-driven runs: cron schedules with timezones, intervals, webhooks, manual runs, and error workflows.
• Versioned deployments: publish an immutable workflow version and pin scheduled deployments to it.
• Chat workflows: test conversations in the editor and share a chat page from your own instance, with login-required or secret-link access.
• API endpoints: define HTTP methods and routes that trigger different branches of a workflow.
• Integrations: HTTP, databases, files, cloud storage, messaging, and business apps, including Postgres, Slack, GitHub, Google Sheets, Notion, Stripe, Airtable, and Outlook.
• Data processing: typed data serialization, artifact-backed datasets, DuckDB transformations, and local or S3-compatible artifact storage.
• Debugging: per-node inputs and outputs, logs, timing, errors, and run history.
• CLI and Python client: manage and run workflows programmatically. Export options include Python scripts, code-first modules, and Docker bundles.

Self-hosting and team features

Docker Compose is the starting point, with Helm/Kubernetes deployment options too. The platform includes local authentication, role-based access, encrypted credentials, credential connection tests, and unsafe-node policies.

The Community edition is free for permitted personal and internal business use, with resource limits. Nodyra is source-available / fair-code under the Sustainable Use License, rather than an OSI-approved open-source license. Paid tiers raise limits and add capabilities such as OpenTelemetry observability; Enterprise features include SSO/SAML/OIDC, multi-tenancy, audit export, and external key management. License verification works offline.

This is a public beta, so I’m looking for people willing to try it, report bugs, and tell me where the workflow feels awkward. There’s no hosted Nodyra service yet. Also, workflows execute arbitrary Python: the default local execution mode assumes trusted authors, and sandboxing must be configured explicitly.

If you try it, I’d particularly like feedback on setup, MCP-driven workflow creation, environment/dependency management, and Docker or remote-worker execution.

What would you build with it, and what would stop you from using it?

PyFirewall is a Windows desktop application for monitoring network connections and managing Windows Defender Firewall rules. It monitors and blocks both incoming and outgoing connections using process and IP/domain specific rules. It uses Tkinter for the interface, Scapy for packet capture, psutil for process and network information, and supports application and global IP/domain rules.

Hi r/PythonProjects2!

A few days ago, I shared an early prototype of this project here, and the feedback was incredible (it even hit the Top 6 posts of the day!). I’ve taken your advice to heart, significantly upgraded the codebase, added comprehensive documentation, and built a proper CLI.

With the "Harvest Now, Decrypt Later" threat becoming a reality, I wanted to build a practical, open-source example of Crypto-Agility.

🔐 What is ChaosCrypt-Hybrid?
It’s a Python library that implements a hybrid encryption scheme, combining classical and post-quantum algorithms to ensure data remains secure even against future quantum computers.

✨ Key Features:

• NIST FIPS 203 Compliant: Uses ML-KEM-768 (formerly Kyber) for quantum-resistant Key Encapsulation Mechanism (KEM).
• Symmetric Payload Encryption: Uses AES-256-GCM for fast, authenticated data encryption (quantum-resistant due to the 256-bit key size).
• Crypto-Agile Architecture: The API is abstracted. You can swap the underlying KEM algorithm without changing your application logic.
• Security-First Design: Implements constant-time comparison principles to mitigate basic timing attacks (with clear documentation on Python's inherent GC limitations).
• Fully Tested & Documented: Includes a robust pytest suite, a SECURITY.md, CONTRIBUTING.md, and a basic_usage.py example.

💻 Quick Example:

from chaoscrypt import HybridCipher


# 1. Initialize the hybrid engine
cipher = HybridCipher(algorithm="ML-KEM-768")


# 2. Generate keys and encrypt a message
public_key, private_key = cipher.generate_keypair()
ciphertext, encapsulated_key = cipher.encrypt(b"Top Secret Data", public_key)


# 3. Decrypt the message
decrypted_data = cipher.decrypt(ciphertext, encapsulated_key, private_key)
print(decrypted_data) # Output: b"Top Secret Data"

🙏 Seeking Your Feedback:
I built this primarily as a deep-dive learning project into post-quantum cryptography and secure software design. I would highly appreciate your code reviews and thoughts on:

1. Are there any edge cases or API design flaws I missed?
2. How would you improve the constant-time guarantees in a Python environment?
3. Any suggestions for the upcoming Rust rewrite of the core engine?

🔗 Links:

• GitHub Repository: https://github.com/uslumurat405-oss/chaoscrypt-hybrid
• Deep Dive Article: I also wrote a detailed technical article about the "Crypto-Agility" architecture and the real-world threat model behind this project. (Note: The article is in Turkish, but the code, diagrams, and technical concepts are universal): https://www.linkedin.com/pulse/kripto-%25C3%25A7eviklik-crypto-agility-kuantum-bilgisayarlar-kap%25C4%25B1dayken-uslu-hbwdf

Thank you for your time and the amazing support this community provides!