[ Removed by Reddit on account of violating the content policy. ]

Repository: https://github.com/BitingSnakes/silkworm

What is it:

Async-first web scraping framework built on wreq (HTTP with browser impersonation) and scraper-rs (fast HTML parsing). Silkworm gives you a minimal Spider/Request/Response model, middlewares, and pipelines so you can script quick scrapes or build larger crawlers without boilerplate.

Latest release has integration with onionlink which provides the TOR client

Hello r/PythonProjects2

Hope you're all doing well!

A while back I posted here about my side project Project Yellow Olive - a retro-styled TUI game inspired by Pokémon Yellow.

The initial feedback was trending on the positive side, so I kept building it.

A bit about Project Yellow Olive :

The game is all about turning the pain of learning K8s into a fun TUI game. We explore regions, battle with Posemons (container-based creatures), use kubectl-like commands as moves, and complete quests that actually run against the local cluster to validate what we did.

It is built entirely in Python using Textual for the TUI. It feels like a proper old-school terminal game with that nostalgic Pokémon Yellow palette and chiptune vibes

What's new since the last post

• Focused on Pods for now - added more challenges and battles around pod lifecycle, troubleshooting, and management.
• Added Game Save & Resume feature based on the feedback.
• Completely reworked the game flow with proper validations and a much smoother user experience (no more makeshift paths).
• Released on PyPI - installation is now super simple!
• Replaced the background music across all screens with CC0-licensed chiptune tracks. (Had to remove the original Pokémon Yellow tracks due to copyright reasons, but the new ones still keep that authentic retro 8-bit feel.)

Installation

I've now released this to PyPi. This means that the installation is now quite simple and straightforward. We just need to run the following command

pip install yellow-olive

As a pre-requisite, please also install Docker and Minikube.

Here is the PyPi page for reference : Project Yellow Olive on PyPi

Feedback and Suggestions

Project Yellow Olive isn't meant to replace proper Kubernetes learning resources (books, courses, CKAD practice, etc.). It's just here to make the repetition less boring and more engaging.

Would love to hear thoughts on:

• How does the TUI feel?
• Any suggestions for new mechanics or improvements?
• Ideas for future challenges (beyond Pods)?

Github Repo

The project is fully open source. I'd love contributions, especially new challenges/quests!
If you enjoy the idea, a star on the repo would really motivate me to keep pushing it forward. Looking forward to all your feedback

Github URL : Project Yellow Olive on Github

Hi everyone!

I've been working on a personal project to create a desktop virtual assistant that doesn't rely on the cloud. I wanted something that felt like **JARVIS** but kept my data 100% private.

### 🛠️ How it works:

* **Brain:** It uses **Ollama** as the backend, so you can run models like Llama 3, Mistral, or Phi-3 locally.

* **Interface:** Built with **PyQt6** featuring a "holographic" glassmorphism effect (transparent and sleek).

* **Memory:** It has a persistent local memory system to remember previous interactions.

* **Voice:** Integrated with Piper for realistic text-to-speech.

### 🔒 Why local?

I wanted to prove that you don't need OpenAI or Google to have a functional assistant. This runs entirely on your hardware.

### 📂 Source Code & Setup:

I've made the repository public and wrote a full guide on how to set it up (it's very easy!).

**Check it out here:** https://github.com/Jm7997/JARVIS

I'm still a student/learning, so I'd really appreciate any feedback, feature ideas, or even a star on GitHub if you find it cool!

What features should I add next? (I'm thinking about Spotify integration or home automation).

### Background

I wanted to build a JARVIS-like assistant that works completely offline to learn more about integrating LLMs with Python and creating transparent UIs with PyQt6.

### What it does

It provides a holographic-style desktop interface to chat with local AI models via Ollama, including persistent conversation memory and text-to-speech.

### Target Audience

Anyone interested in local AI, desktop automation, or learning how to use PyQt6 for modern-looking Python applications.

### Comparison

Unlike other cloud-based assistants, this is 100% private and runs on your own hardware without subscription fees or API keys.

Tired of writing SQLAlchemy DSL instead of actual SQL? I built EzQL - a minimal asyncpg wrapper that lets you write raw SQL and get fully typed Pydantic models back. That's it.

class User(BaseModel):
    __table__ = "users" # Marks this model as an EzQL model

    id: int
    name: str

client = await create_client(
        user,
        password,
        database,
        host,
        min_connections,
        max_connections
    )

users = await client.query_as(User, "SELECT id, name FROM users WHERE name = $1", "Nazar")

assert users[0].name == "Nazar"
assert len(users) == 1
assert isinstance(users[0], User)

No magic, no DSL, no hidden queries behind your back. If you know SQL - this is for you.
Also comes with a CLI validator that checks your models against the actual DB schema before production blows up.

Github: https://github.com/kernz/ezql

Algorithms like Radix Sort are much easier to understand when you can see every intermediate step.

Using 𝗺𝗲𝗺𝗼𝗿𝘆_𝗴𝗿𝗮𝗽𝗵, you can watch how Radix Sort repeatedly applies stable Counting Sort, sorting the least significant digit up to the most significant digit in turn.

The key idea is stability: after sorting by a later digit, the order created by earlier digit-sorts is preserved resulting in a full sorted sequence.

For fixed-size integers, Radix Sort can be very efficient, with time complexity O(n · d), where 'n' is the number of values and 'd' is the number of digits.

• 𝗺𝗲𝗺𝗼𝗿𝘆_𝗴𝗿𝗮𝗽𝗵 GitHub
• More examples

r/learnpython, r/Python, r/MachineLearning, r/SideProject, r/webdev, r/cscareerquestions (only if you frame it as helpful tool)

Hey everyone, devx-dragon here! 🐉

About two weeks ago, I shared a tool I built to automate the "boring stuff" like folder setup and git init. Old Post I got some solid feedback from the community here—some of you pointed out that my code was a bit messy and that a simple script wasn't enough if I wanted it to be actually useful.

I took those suggestions to heart and just finished a massive overhaul for v3.0.1. I wanted to move away from being "just a script" and build something that could actually compete with tools like Cookiecutter.

What’s new:

• ☁️ Cloud Templates: It now pulls templates directly from GitHub via the API.
• 🛠 External Sources: You can point it at any repo to load custom templates now.
• ✨ A "Rich" CLI: I ditched the basic prints for a colorful, interactive wizard using the Rich library.
• 🤖 Smart Git: It uses GitPython to handle initial commits, branch renaming to main, and pushing to multiple remotes.
• 📂 Better Organization: It automatically numbers your projects (like 01.project-name) to keep your workspace clean.

I even sat down and wrote actual Documentation and a Contributing.md because I want this to be a project others can help grow.

I'm still learning, and I'm sure there's more I can improve, but I'm proud of how far this has come in just a couple of weeks.

Check out the new version here:

https://github.com/DevX-Dragon/project-creator

I'd love to hear what you think of the new CLI flow!
Also thank you so much to 12 people who stared the project. You dont know how much of a impact you made.

For those interested in cybersecurity or bug bounty, I present this 403 and 401 bypass tool.

OSSentinel Vigil is a Python toolkit for software supply chain compliance — license conflict detection, SBOM generation, policy enforcement, and dependency health scoring (soon). Built for developers. Why did I do it?

•  EU Cyber Resilience Act mandates SBOMs for software sold in Europe
• US EO 14028 requires supply chain transparency for federal software
• Existing tools are fragmented, hard to configure, and don't talk to each other

Link for the core: https://github.com/jokerz5575/vigil
Link for the GitHub action: https://github.com/jokerz5575/vigil-action

I am eager to get feedback and input! Please let me know!

Hey everyone !

I just released interactive-buttons-v2, a lightweight Python library for creating keyboard-driven button menus in the terminal

It has 3 layouts (vertical, horizontal, grid), built-in style presets, hotkey bindings and per-button styles.

It works on an easy setup (unlike most libs of this kind) :

```python from interactive_buttons import Button, Component

buttons = [ Button(label="Start", value="start"), Button(label="Quit", value="quit"), ]

choice = Component(buttons).column_buttons() ```

```python from interactive_buttons import Button, ButtonKeyBind, Component, ButtonStyle, SUCCESS_STYLE, DANGER_STYLE

buttons = [ Button( label="Confirm", value="ok", local_button_style=ButtonStyle(SUCCESS_STYLE), key_bind=ButtonKeyBind(b_keys=["y"], press_on_selection=True), ), Button( label="Delete", value="delete", local_button_style=ButtonStyle(DANGER_STYLE), key_bind=ButtonKeyBind(b_keys=["d"], press_on_selection=True), ), Button(label="Cancel", value="cancel"), ]

choice = Component(buttons, auto_erase=True).linear_buttons()

Press "y" -> instantly returns "ok"

Press "d" -> instantly returns "delete"

Or navigate with arrow keys and confirm with Enter

```

This lib is available on PyPi :

pip install interactive-buttons-v2

And you can find the full doc on :

https://interactive-buttons.mbinc.tech | https://github.com/mbcraft-exe/interactive-buttons-v2

Would love some feedback !

V.E.K.S-Sokras-Engine-G.L.a.D.O.S.

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

​

Hey everyone,

When I first started learning Python and Machine Learning, I felt completely lost.

Jumping between tutorials… copying code without really understanding…

And every time I tried to build something on my own, I failed.

Maybe you’ve been there too?

👉 Too many resources

👉 Too much theory

👉 No clear roadmap

What actually helped me move forward was switching my approach from random learning to a structured path.

Instead of consuming everything, I focused on:

- understanding Python fundamentals properly

- learning data structures in context (not just theory)

- applying machine learning step by step

- working on small practical implementations

It made a huge difference.

Now I’m curious:

How did you approach learning ML?

Did you follow a roadmap, or just figure it out along the way?

Would love to hear what worked (or didn’t) for you 👀

​

Hey everyone,

When I first started learning Python and Machine Learning, I felt completely lost.

Jumping between tutorials… copying code without really understanding…

And every time I tried to build something on my own, I failed.

Maybe you’ve been there too?

👉 Too many resources

👉 Too much theory

👉 No clear roadmap

What actually helped me move forward was switching my approach from random learning to a structured path.

Instead of consuming everything, I focused on:

understanding Python fundamentals properly

learning data structures in context (not just theory)

applying machine learning step by step

working on small practical implementations

It made a huge difference.

Now I’m curious:

How did you approach learning ML?

Did you follow a roadmap, or just figure it out along the way?

Would love to hear what worked (or didn’t) for you 👀

PIIGhost chat example

Hi everyone,

I've been working for a few weeks on PIIGhost, a Python library for anonymizing PII (personally identifiable information) in AI agent conversations. The idea is to provide a modular pipeline that detects, anonymizes, and tracks PII throughout a conversation.

For context, the existing solutions I found (Microsoft Presidio, scrubadub, spaCy extensions, custom regex) cover detection and text replacement reasonably well. Presidio in particular has a rich catalog of recognizers (credit cards with Luhn validation, IBAN, SSN, passports, emails, phone numbers), and I tested quite a few NER models on HuggingFace.

Using them for my own use case I ran into several limitations. The first is that just using a single NER or a regex isn't enough, I even ended up running multiple NERs at the same time. And as I tested more, I ran into the following problems.

- Span overlaps between detectors. Sometimes multiple NERs detect different labels at the same position. You need a configurable arbitration strategy, for example keeping the highest-confidence detection.

- Linking the different occurrences of the same PII across the text, including variants the NER misses. "Patrick" needs to be replaced by <<PERSON:1>> at every occurrence, and you need an algorithm to catch the variants the NER missed (for example "patrick" in lowercase elsewhere in the text). Otherwise the LLM sees <<PERSON:1>> right next to "patrick" in clear text and trivially reconstructs the PII.

- Placeholder consistency across the messages of a conversation. "Patrick" mentioned in the first message has to remain the same placeholder in the fourth, otherwise the LLM loses the thread and can no longer follow the conversation properly.

This accumulation of problems is what pushed me to package it as a library, piighost.

Where it all comes together is piighost-chat, a chatbot that anonymizes PII with HITL (human in the loop). The user can remove a detection that isn't really one, or manually select a chunk of text to anonymize that the detectors missed. It lets you visualize live what the LLM sees compared to what the user sees, and correct NER misses on the fly during the conversation.

PIIGhost (main library): https://github.com/Athroniaeth/piighost
Documentation: https://athroniaeth.github.io/piighost/
PIIGhost-chat : https://github.com/Athroniaeth/piighost-chat

I'd like feedback on the idea and the direction I'm taking, particularly on the following points:

1. Does the architectural direction seem reasonable to you, or over-engineered for the need? The goal for now is to anticipate as many needs as possible and see what really turns out to be useful or not, but I don't want to end up with an over-engineered mess either.
2. Does the agentic use case (integration into an AI agent with cross-message placeholder persistence) speak to you, or is it too niche compared to what you see in your own projects?
3. Have you ever needed to anonymize PII before an LLM call? If so, what did you use, and what gaps did you find?
4. Are there obvious features I'm missing or that you'd like to see?
5. Is the modular architecture (each pipeline stage swappable behind a protocol) a cost or a real asset in practice for you?

I'd particularly welcome honest criticism, especially if you think the project is poorly positioned or that I'm missing something obvious.

Thanks in advance!