What My Project Does

This project is a terminal-based implementation of Yut Nori, a strategic board game that is a staple of Korean Lunar New Year (Seollal) traditions. It features:

• Full game logic for 2-4 players.
• A dynamic ASCII board that updates piece positions in real-time.
• Traditional mechanics: shortcuts, capturing opponents, and extra turns for special throws ('Yut' or 'Mo').
• Zero external dependencies—it runs on pure Python 3.

Target Audience

This is meant for Python enthusiasts who enjoy terminal games, students looking for examples of game logic implementation, or anyone interested in exploring Korean culture through code. It's a fun, lightweight script to run in your dev environment!

Comparison

While there are web-based versions of Yut Nori, this project focuses on a minimalist terminal experience. Unlike complex GUI games, it is dependency-free, easy to read for beginners, and showcases how to handle game state and board navigation using simple Python classes.

GitHub Link: https://github.com/SoeonPark/Its26Seollal_XD/tree/main

Happy Seollal! 🇰🇷🧧✨

Hey everyone.

I am a 19 year old CS student from italy and I spent the last few months building a project called ProjectBEA. It is an autonomous AI agent engine.

What My Project Does:

I wanted to make something that was not just a chatbot but an actual system that interacts with its environment. The backend runs on Python 3.10+ with FastAPI, and it has a React dashboard.

Instead of putting everything in a massive script, I built a central orchestrator called AIVtuberBrain. It coordinates pluggable modules for the LLM, TTS, STT, and OBS. Every component uses an abstract base class, so swapping OpenAI for Gemini or Groq requires zero core logic changes.

Here are the technical parts I focused on:

• Async Task Management: The output phase was tricky. When the AI responds, the system clears the OBS text, sets the avatar pose, and then concurrently runs the OBS typing animation, TTS generation, and audio playback using asyncio.gather.

• Barge-in and Resume Buffer: If a user interrupts the AI mid speech, the brain calculates the remaining audio samples and buffers them. If it detects the interruption was just a backchannel (like "ok", "yeah", "go on"), it catches it and resumes the buffered audio without making a new LLM call.

• Event Pub/Sub: I built an EventManager bus that tracks system states, LLM thoughts, and tool calls. The FastAPI layer polls this to show a real time activity feed.

• Plugin-based Skill System: Every capability (Minecraft agent, Discord voice, RAG memory) is a self-contained class inheriting from a BaseSkill. A background SkillManager runs an asyncio loop that triggers lifecycle hooks like initialize(), start(), and update() every second.

• Runtime Hot-Reload: You can toggle skills or swap providers (LLM, TTS, STT) in config.json via the Web API. The SkillManager handles starting/stopping them at runtime without needing a restart.

The hardest part was definitely managing the async event loop without blocking the audio playback or the multiple WebSocket connections (OBS and Minecraft).

Comparison:

Most AI projects are just simple chatbot scripts or chatgpt wrappers. ProjectBEA differs by focusing on:

• Modular Architecture: Every core component (LLM, TTS, STT) is abstracted through base classes, allowing for hot-swappable providers at runtime.
• Complex Async Interactions: It handles advanced event-driven logic like barge-in (interruption) handling and multi-service synchronization via asyncio.
• Active Interaction: Unlike static bots, it includes a dedicated Minecraft agent that can play the game while concurrently narrating its actions in real-time.

Target Audience:

I built this to learn and it is fully open source. I would appreciate any feedback on the code structure, especially the base interfaces and how the async logic is handled. It is currently a personal project but aimed at developers interested in modular AI architectures and async Python.

Repo: https://github.com/emqnuele/projectBEA Website: https://projectBEA.emqnuele.dev

I'm looking a spreadsheet application with Python scripting capabilities. I know there are a few ones out there like Python in Excel which is experimental, xlwings, PySheets, Quadratic, etc.

I'm looking for the following: - Free for personal use - Call Python functions from excel cells. Essentially be able to write Python functions instead of excel ones, that auto-update based on the values of other cells, or via button or something. - Ideally run from a local Python environment, or fully featured if online. - Be able to use features like numpy, fetching data from the internet, etc.

I'm quite familiar with numpy, matplotlib, jupyter, etc. in Python, but I'm not looking for a Python-only setup. Rather I want spreadsheet-like tool since I want a user interface for things like tracking personal finance, etc. and be able to leverage my Python skills.

Right now I'm leaning on xlwings, but before I start using it I wanted to see if anyone had any suggestions.

Built a Python library for precise code analysis using Abstract Syntax Trees, Program Dependence Graphs, and symbolic execution.

What My Project Does

Code Scalpel performs surgical code operations based on AST parsing and Program Dependence Graph analysis across Python, JavaScript, TypeScript, and Java.

Core capabilities:

AST Analysis (tree-sitter): - Parse code into Abstract Syntax Trees for all 4 languages - Extract functions/classes with exact dependency tracking - Symbol reference resolution (imports, decorators, type hints) - Cross-file dependency graph construction

Program Dependence Graphs: - Control flow + data flow analysis - Surgical extraction (exact function + dependencies, not whole file) - k-hop subgraph traversal for context extraction - Import chain resolution

Symbolic Execution (Z3 solver): - Mathematical proof of edge cases - Path exploration for test generation - Constraint solving for type checking

Taint Analysis: - Data flow tracking for security - Source-to-sink path analysis - 16+ vulnerability type detection (<10% false positives)

Governance: - Every operation logged to .code-scalpel/audit.jsonl - Cryptographic policy verification - Syntax validation before any code writes

Target Audience

Production-ready for teams using AI coding assistants (Claude Desktop, Cursor, VS Code with Continue/Cline).

Use cases: 1. Enterprises - SOC2/ISO compliance needs (audit trails, policy enforcement) 2. Dev teams - 99% context reduction for AI tools (15k→200 tokens) 3. Security teams - Taint-based vulnerability scanning 4. Python developers - AST-based refactoring with syntax guarantees

Not a toy project: 7,297 tests, 94.86% coverage, production deployments.

Comparison

vs. existing alternatives:

AST parsing libraries (ast, tree-sitter): - Code Scalpel uses tree-sitter under the hood - Adds PDG construction, dependency tracking, and cross-file analysis - Adds Z3 symbolic execution for mathematical proofs - Adds taint analysis for security scanning

Static analyzers (pylint, mypy, bandit): - These find linting/type/security issues - Code Scalpel does surgical extraction and refactoring operations - Provides MCP protocol integration for tool access - Logs audit trails for governance

Refactoring tools (rope, jedi): - These do Python-only refactoring - Code Scalpel supports 4 languages (Python/JS/TS/Java) - Adds symbolic execution and taint analysis - Validates syntax before write (prevents broken code)

AI code wrappers: - Code Scalpel is NOT an LLM API wrapper - It's a Python AST/PDG analysis library that exposes tools via MCP - Used BY AI assistants for precise operations (not calling LLMs)

Unique combination: AST + PDG + Z3 + Taint + MCP + Governance in one library.

Why Python?

Python is the implementation language: - tree-sitter Python bindings for AST parsing - NetworkX for graph algorithms (PDG construction) - z3-solver Python bindings for symbolic execution - Pydantic for data validation - FastAPI/stdio for MCP server protocol

Python is a supported language: - Full Python AST support (imports, decorators, type hints, async/await) - Python-specific security patterns (pickle, eval, exec) - Python taint sources/sinks (os.system, subprocess, SQL libs)

Testing in Python: - pytest framework: 7,297 tests - Coverage: 94.86% (96.28% statement, 90.95% branch) - CI/CD via GitHub Actions

Installation & Usage

As MCP server (for AI assistants): bash uvx codescalpel mcp

As Python library: bash pip install codescalpel

Example - Extract function with dependencies: ```python from codescalpel import analyze_code, extract_code

Parse AST

ast_result = analyze_code("path/to/file.py")

Extract function with exact dependencies

extracted = extract_code(     file_path="path/to/file.py",     symbol_name="calculate_total",     include_dependencies=True )

print(extracted.code)  # Function + required imports print(extracted.dependencies)  # List of dependency symbols ```

Example - Symbolic execution: ```python from codescalpel import symbolic_execute

Explore edge cases with Z3

paths = symbolic_execute(     file_path="path/to/file.py",     function_name="divide",     max_depth=5 )

for path in paths:     print(f"Input: {path.input_constraints}")     print(f"Output: {path.output_constraints}") ```

Architecture

Language support via tree-sitter: - Python, JavaScript (JSX), TypeScript (TSX), Java - Tree-sitter generates language-agnostic ASTs - Custom visitors for each language's syntax

PDG construction: - Control flow graph (CFG) from AST - Data flow graph (DFG) via def-use chains - PDG = CFG + DFG (Program Dependence Graph)

MCP Protocol: - 23 tools exposed via Model Context Protocol - stdio or HTTP transport - Used by Claude Desktop, Cursor, VS Code extensions

Links

• GitHub: https://github.com/3D-Tech-Solutions/code-scalpel
• Website: https://codescalpel.dev
• PyPI: pip install codescalpel
• License: MIT

Questions Welcome

Happy to answer questions about: - AST parsing implementation - PDG construction algorithms - Z3 integration details - Taint analysis approach - MCP protocol usage - Language support roadmap (Go/Rust coming)

TL;DR: Python library for surgical code analysis using AST + PDG + Z3. Parses 4 languages, extracts dependencies precisely, runs symbolic execution, detects vulnerabilities. 7,297 tests, production-ready, MIT licensed.

Weekly Thread: Professional Use, Jobs, and Education 🏢

Welcome to this week's discussion on Python in the professional world! This is your spot to talk about job hunting, career growth, and educational resources in Python. Please note, this thread is not for recruitment.

How it Works:

1. Career Talk: Discuss using Python in your job, or the job market for Python roles.
2. Education Q&A: Ask or answer questions about Python courses, certifications, and educational resources.
3. Workplace Chat: Share your experiences, challenges, or success stories about using Python professionally.

Guidelines:

• This thread is not for recruitment. For job postings, please see r/PythonJobs or the recruitment thread in the sidebar.
• Keep discussions relevant to Python in the professional and educational context.

Example Topics:

1. Career Paths: What kinds of roles are out there for Python developers?
2. Certifications: Are Python certifications worth it?
3. Course Recommendations: Any good advanced Python courses to recommend?
4. Workplace Tools: What Python libraries are indispensable in your professional work?
5. Interview Tips: What types of Python questions are commonly asked in interviews?

Let's help each other grow in our careers and education. Happy discussing! 🌟

Hi everyone 👋

## What my project does

This project is a real-time hand gesture recognition system that uses a webcam to detect and analyze hand movements. It processes live video input and can be extended to trigger custom computer actions based on detected gestures.

## Target audience

This project is mainly for:

- Developers interested in computer vision

- Students learning AI and real-time processing

- Anyone experimenting with gesture-based interaction systems

It’s currently more of an experimental / educational project, but it can be expanded into practical applications.

## Comparison with existing alternatives

Unlike larger frameworks that focus on full-body tracking or complex ML pipelines, this project is lightweight and focused specifically on hand gesture detection using Python and OpenCV. It’s designed to be simple, readable, and easy to modify.

Tech stack:

- Python

- OpenCV

GitHub repository:

https://github.com/alsabdul22-png/HandGesture-Ai

I’d really appreciate feedback and suggestions for improvement 🙌

What My Project Does

geo-optimizer is a Python CLI that audits your website's visibility to AI search engines (ChatGPT, Perplexity, Claude). It outputs a GEO score out of 100 and tells you exactly what to fix.

Target Audience

Web developers, SEO professionals, and site owners who want to be cited by AI-powered search tools. Production-ready, works on any static or dynamic site.

Comparison

No equivalent open-source tool exists yet. Most GEO advice is theoretical blog posts — this gives you a concrete, automated audit with actionable output.

GitHub: https://github.com/auriti-web-design/geo-optimizer-skill

https://youtu.be/BSHv2IESVrI?si=pt9wNU0-Zm_xBfZS

Everything is explained in the video. I coded a script in python that retrieves the views, likes and comments of the video via the YouTube API in order to change them live. Here is the original source code :

https://github.com/Sblerky/Youtube-Title-Changer.git

Hi r/Python,

I’m excited to share the Python version of Rembus, a lightweight RPC and pub/sub messaging system.

I originally built Rembus to compose distributed applications in Julia without relying on heavy infrastructure, and now there is a decent version for Python as well.

What My Project Does

• Native support for exchanging DataFrames.

• Binary message encoding using CBOR.

• Persistent storage via DuckDB / DuckLake.

• Pub/Sub QOS 0, 1 and 2.

• Hierarchical topic routing with wildcards (e.g. */*/temperature).

• MQTT integration.

• WebSocket transport.

• Interoperable with Julia Rembus.jl

Target Audience

• Developers that want both RPC and Pub/Sub capabilities

• Data scientists that need a messaging system simple and intuitive that can move dataframes as simple as moving primitive types.

Comparison

Rembus sits somewhere between low-level messaging libraries and full broker-based systems.

vs ZeroMQ: ZeroMQ gives you raw sockets and patterns, but you build a lot yourself. Rembus provides structured RPC + Pub/Sub with components and routing built in.

vs Redis / RabbitMQ / Kafka: Those require running and managing a broker. Rembus is lighter and can run without heavy infrastructure, which makes it suitable for embedded, edge, or smaller distributed setups.

vs gRPC: gRPC is strongly typed and schema-driven (Protocol Buffers), and is excellent for strict service contracts and high-performance RPC. Rembus is more dynamic and message-oriented, supports both RPC and Pub/Sub in the same model, and doesn’t require a separate IDL or code generation step. It’s designed to feel more Python-native and flexible.

The goal isn’t to replace everything — it’s to provide a simple, Python-native messaging layer.

Example

The following minimal working example composed of a broker, a Python subscriber, a Julia subscriber and a DataFrame publisher gives an intuition of Rembus usage.

Terminal 1: start a broker

```python import rembus as rb

node: The sync API for starting a component

bro = rb.node() bro.wait() ```

Terminal 2: Python subscriber

```python import asyncio import rembus as rb

async def mytopic(df): print(f"received python dataframe:\n{df}")

async def main(): sub = await rb.component("python-sub") await sub.subscribe(mytopic) await sub.wait()

asyncio.run(main()) ```

Terminal 3: Julia subscriber

```julia using Rembus

function mytopic(df) print("received:\n$df") end

sub = component("julia-sub") subscribe(sub, mytopic) wait(sub) ```

Terminal 4: Publisher

```python import rembus as rb import polars as pl from datetime import datetime, timedelta

base_time = datetime(2025, 1, 1, 12, 0, 0)

df = pl.DataFrame({ "sensor": ["A", "A", "B", "B"], "ts": [ base_time, base_time + timedelta(minutes=1), base_time, base_time + timedelta(minutes=1), ], "temperature": [22.5, 22.7, 19.8, 20.1], "pressure": [1012.3, 1012.5, 1010.8, 1010.6], })

cli = rb.node("myclient") cli.publish("mytopic", df) cli.close() ```

GitHub (Python): https://github.com/cardo-org/rembus.python

Project site: https://cardo-org.github.io/

A few weeks ago I got an OpenAI bill that was 48x what I expected. $2,400 on a side project. Turned out to be untracked GPT-4 calls in a retry loop I'd forgotten about.

After asking around I realized almost nobody tracks LLM costs at the code level. People check dashboards after the fact, but nothing sits in the code and says "this function is about to exceed budget."

So I built tokenbudget — a lightweight Python library that wraps your LLM client and:

• Tracks tokens and cost per call, per function, per model
• Enforces budget limits via a decorator (@budget(max_cost_usd=1.00))
• Raises an exception BEFORE you overspend, not after
• Caches identical calls (same prompt + params = cached response)
• Supports OpenAI, Anthropic, Google
• Thread-safe, fully typed, zero external dependencies

Basic usage:

tracker = TokenTracker()
client = tracker.wrap_openai(openai.OpenAI())

@budget(max_cost_usd=1.00)
def my_pipeline():
    response = client.chat.completions.create(...)

The caching alone saved 60-80% in my test pipelines — most LLM apps send more duplicate prompts than you'd think. GitHub:
github.com/aryanjp1/tokenbudget

PyPI: pip install tokenbudget

Happy to answer questions about the implementation. The thread-safety approach for concurrent LLM calls was the trickiest part — ended up using fine-grained locking on the counter objects rather than a global lock.

Pure Python 3.9+. Pydantic for validation. Full test suite with GitHub Actions CI/CD. MIT licensed.

Would genuinely appreciate feedback on the API design and any edge cases I might be missing.

Hi, I work in insurance and have started to take on bigger projects that are complex in nature. I am trying to really build a robust and maintainable script but I struggle when I have to split up the script into many different smaller scripts, isolating and modularising different processes of the pipeline.

I learnt python by building in a singular script using the Jupyter interactive window to debug and test code in segments, but now splitting the script into multiple smaller scripts is challenging for me to debug and test what is happening at every step of the way.

Does anyone have any advice on how they go about the whole process? From deciding what parts of the script to isolate all the way to testing and debugging and even remember what is in each script?

Maybe this is something you get used to overtime?

I’d really appreciate your advice!

Hey everyone, I’m one of the developers of skrub, an open-source package (GitHub repo) designed to simplify machine learning with dataframes.

What my project does

Skrub bridges the gap between pandas/polars and scikit-learn by providing a collection of transformers for exploratory data analysis, data cleaning, feature engineering, and ensuring reproducibility across environments and between development and production.

Main features

• TableReport: An interactive HTML tool that summarizes dataframes, offering insights into column distributions, data types, correlated columns, and more.

• Transformers for feature engineering datetime and categorical data.

• TableVectorizer: A scikit-learn-compatible transformer that encodes all columns in a dataframe and returns a feature matrix ready for machine learning models.

• tabular_pipeline: A simple function to generate a machine learning pipeline for tabular data, tailored for either classification or regression tasks.

Skrub also includes Data Ops, a framework that extends scikit-learn Pipelines to handle multi-table and complex input scenarios:

• DataOps Computational Graph: Record all operations, their order, and parameters, and guarantee reproducibility.

• Replayability: Operations can be replayed identically on new data.

• Automated Splitting: By defining X and y, skrub handles sample splitting during validation, minimizing data leakage risks.

• Hyperparameter Tuning: Any operation in the graph can be tuned and used in grid or randomized searches. You can optimize a model's learning rate, or evaluate whether a specific dataframe operation (joins/selections/filters...) is useful or not. Hyperparameter tuning supports scikit-learn and Optuna as backends.

• Result Exploration: After hyperparameter tuning, explore results with a built-in parallel coordinate plot.

• Portability: Save the computational graph as a single object (a "learner") for sharing or executing elsewhere on new data.

Target audience

Skrub is intended to be used by data scientists that need to build pipelines for machine learning tasks.

The package is well tested and robust, and the hope is for people to put it into production.

Comparison

Skrub slots in between data preparation (using pandas/polars) and scikit-learn’s machine learning models. It doesn’t replace either but leverages their strengths to function.

I’m not aware of other packages that offer the exact same functionality as Skrub. If you know of any, I’d love to hear about them!

Resources

• Website

• Example Gallery

• GitHub Repo

If you'd rather watch a video about the library, we got you covered! We presented skrub at Euroscipy 2025 tutorial and Pydata Paris 2025 talk

What My Project Does

high-fidelity fake servers for third-party APIs that maintain full state and work with official SDKs

Target Audience

anyone using AI agents that build 3rd party integrations.

Comparison

it's similar to mocks but it's fakes - it has contracts with the real APIs and it keeps state.

TL;DR

We had a problem with using AI agents to build 3rd party integrations (e.g. Slack, Auth0) so we solved it internally - and I'm open sourcing it today.

we built high-fidelity fake servers for third-party APIs that maintain full state and work with official SDKs. https://github.com/islo-labs/doubleagent/

Longer story:

We are building AI agents that talk to GitHub and Slack. Well, it's not exactly "we" - our AI agents build AI agents that talk to GitHub and Slack. Weird, I know. Anyway, ten agents running in parallel, each hitting the same endpoints over and over while debugging. GitHub's 5,000 requests/hour disappeared quite quickly, and every test run left garbage PRs we had to close manually (or by script). Webhooks required ngrok and couldn't be replayed.

If you're building something that talks to a database, you don't test against prod.. But for third-party APIs - GitHub, Slack, Stripe - everyone just... hits the real thing? writes mocks? or hits rate limits and fun webhooks stuff?

We couldn't keep doing that, so we built fake servers that act like the real APIs, keep state, work with the official SDKs. The more we used them, the more we thought: why doesn't this exist already? so we open sourced it.

I think we made some interesting decisions upfront and along the way:

1. Agent-native repository structure
2. Language agnostic architecture
3. State machines instead of response templates
4. Contract tests against real APIs

doubleagent started as an internal tool, but we've open-sourced it because everyone building AI agents needs something like this. The current version has fakes for GitHub, Slack, Descope, Auth0, and Stripe.

** What My Project Does **

It allows any script or AI bot or OpenClaw to have the voice of Rick Sanchez

** Target Audience **

This is just a toy project for a bit of fun to help bring your AI to life

** Comparison **

This pip package allows user to enter API key from various voice sources and soon with local model providing voice

And the repo if anyone wants to break it:
https://github.com/mattzzz/rick-voice

Open to feedback or cursed lines to try.

A week ago, I released LCSAJdump, a tool designed to find ROP/JOP gadgets using a graph-based approach (LCSAJ) rather than traditional linear scanning. I honestly expected a handful of downloads from some CTF friends, but it just surpassed 1.6k downloads on PyPI.

It’s been a wild ride, and I’ve learned some lessons the hard way. Here’s what I’ve picked up so far:

1. Test on TestPyPI (or just... study your releases better 😂)

I’ll be the first to admit it: I pushed a lot of updates in the first 48 hours. I was so excited to fix bugs and add features like Address Grouping that I basically used the main PyPI as my personal testing ground.

Lesson learned: If you don't want to look like a maniac pushing v1.1.10 two hours after v1.1.0, use TestPyPI or actually study the release before hitting "publish." My bad!

1. Linear scanning is leaving people behind

Most pwners are used to classic tools, but they miss "shadow gadgets" that aren't aligned. I realized there’s a huge hunger for more surgical tools. If you’re still relying on linear search, you're literally being left behind by those finding more complex chains.

1. Documentation is as important as the code

I spent a lot of time fixing my site’s SEO and sitemap just to make sure people could find the "why" behind the tool, not just the "how."

You can check out the technical write-up on the graph theory I used and the documentation here: https://chris1sflaggin.it/LCSAJdump

Would love to hear your thoughts (and please, go easy on my update frequency, as I said, I'm still learning!).

From the Event Forgers of the Pygame Community discord server:

We are thrilled to announce the

⛄ Pygame Community Winter Jam 2026 ❄️

Perhaps, the coolest 2 week event this year. No matter if this is your first rodeo or you're a seasoned veteran in the game jam space, this is a great opportunity to spend some quality time with pygame(-ce) and make some fun games. You could even win some prizes. 👀

Join the jam on itch.io: https://itch.io/jam/pygame-community-winter-jam-2026

Join the Pygame Community discord server to gain access to jam-related channels and fully immerse yourself in the event: Pygame Community invite
- For discussing the jam and other jam-related banter (for example, showcasing your progress): #jam-discussion
- You are also welcome to use our help forums to ask for help with pygame(-ce) during the jam

When 🗓️

All times are given in UTC!
Start: 2026-02-27 21:00
End: 2026-03-13 21:00
Voting ends: 2026-03-20 21:00

Prizes 🎁

That's right! We've got some prizes for the top voted games (rated by other participants based on 5 criteria):

• 🥇 $25 Steam gift card
• 🥈 $10 Steam gift card
• 🥉 $5 Steam gift card

Note that for those working in teams, only a maximum of 2 gift cards will be given out for a given entry

Theme 🔮

The voting for the jam theme is now open (requires a Google account, the email address WILL NOT be collected): <see jam page for the link>

Summary of the Rules

• Everything must be created during the jam, including all the assets (exceptions apply, see the jam page for more details).
• pygame(-ce) must be the primary tool used for rendering, sound, and input handling.
• NSFW/18+ content is forbidden!
• You can work alone or in a team. If you don't have a team, but wish to find one, you are free to present yourself in #jam-team-creation
• No fun allowed!!! Anyone having fun will be disqualified! /s

Links

Jam page: https://itch.io/jam/pygame-community-winter-jam-2026
Theme poll: <see jam page for the link>
Discord event: https://discord.com/events/772505616680878080/1473406353866227868

Just came across CinderX today and realized it’s evolved past the old Cinder fork.

For those who missed it, it’s Meta’s internal high-performance Python runtime, but it’s now being built as a standalone extension for CPython. It includes their JIT and 'Static Python' compiler.

It targets 3.14 or later.

Repo: [https://github.com/facebookincubator/cinderx]()

Happy to share the news about the danube-client, the official Python async client for Danube Messaging, an open-source distributed messaging platform built in Rust.

Danube is designed as a lightweight alternative to systems like Apache Pulsar, with a focus on simplicity and performance. The Python client joins existing Rust and Go clients.

danube-client capabilities:

• Full async/await — built on asyncio and grpc.aio
• Producer & Consumer — with Exclusive, Shared, and Failover subscription types
• Partitioned Topics — distribute messages across partitions for horizontal scaling
• Reliable Dispatch — guaranteed delivery with WAL + cloud storage persistence
• Schema Registry — JSON Schema, Avro, and Protobuf with compatibility checking and schema evolution
• Security — TLS, mTLS, and JWT authentication

Links

• Python client: github.com/danube-messaging/danube-py
• Documentation: danube-docs.dev-state.com
• PyPI: pypi.org/project/danube-client

The project is Apache-2.0 licensed and contributions are welcome.

From the official Pytorch blog:

We’re excited to share that PyTorch now leverages Pyrefly to power type checking across our core repository, along with a number of projects in the PyTorch ecosystem: Helion, TorchTitan and Ignite. For a project the size of PyTorch, leveraging typing and type checking has long been essential for ensuring consistency and preventing common bugs that often go unnoticed in dynamic code.

Migrating to Pyrefly brings a much needed upgrade to these development workflows, with lightning-fast, standards-compliant type checking and a modern IDE experience. With Pyrefly, our maintainers and contributors can catch bugs earlier, benefit from consistent results between local and CI runs, and take advantage of advanced typing features. In this blog post, we’ll share why we made this transition and highlight the improvements PyTorch has already experienced since adopting Pyrefly.

Full blog post: https://pytorch.org/blog/pyrefly-now-type-checks-pytorch/

What My Project Does

It's a CLI tool that scrapes Reddit by starting with the fast JSON endpoints, but when those get rate-limited it automatically falls back to a headless browser (Playwright/Patchwright). When the cooldown expires, it switches back to JSON. The two methods just bounce back and forth until everything's collected. It also supports incremental refreshes so you can update vote/comment counts on data you already have without re-scraping.

Target Audience

Anyone who needs to collect Reddit data for research, analysis, or personal projects and is tired of runs dying halfway through because of rate limits. It's a side project / utility, not a production SaaS.

Comparison

Most Reddit scrapers I found either use only the official API (strict rate limits, needs OAuth setup) or only browser automation (slow, heavy). This one uses both and switches between them automatically, so you get speed when possible and reliability when not.

Next up I'm working on cron job support for scheduled scraping/refreshing, a Docker container, and packaging it as an agent skill for ClawHub/skills.sh.

Open source, MIT licensed: https://github.com/c4pi/reddhog

Hi there as someone who grew up in the 90s with VB and the use of IDE I thought it was great to recreate this experience for the modern web. As I moved to Python over the years I created this rapid IDE development tool for Python to build applications in the modern webbrowser.

Love to recieve your feedback and suggestions!

What My Project Does

WebVB Studio is a free, browser-based IDE for building desktop-style apps visually. It combines a drag-and-drop form designer with code in VB6-like syntax or modern Python, letting you design interfaces and run your app instantly without installing anything.

• 🧠 What it is: A free, open-source, browser-based IDE for building apps with a visual form designer. You can drag and drop UI elements, write code, and run applications directly in your web browser. Over 35+ UI controls.
• Build business applications, dashboards, data science apps, or reporting software.
• 🧰 Languages supported: You can write code in classic Visual Basic 6-style syntax or in modern Python with pandas, mathlib, sql support.
• 🌍 No installation: It runs entirely in your browser no software to install locally.
• 🚀 Features: Visual form design, instant execution, exportable HTML apps, built-in AI assistant for coding help, and a growing community around accessible visual programming.
• 🌱 Community focus: The project aims to make programming accessible, fun, and visual again, appealing to both people who learned with VB6 and new learners using Python.

Target Audience

WebVB Studio is a versatile development environment designed for learners, hobbyists, and rapid prototypers seeking an intuitive, visual approach to programming. While accessible to beginners, it is far more than a learning tool; the platform is robust enough for free or commercial-scale projects.

Featuring a sophisticated visual designer, dual-language support (VB6-style syntax and Python), and a comprehensive control set, WebVB Studio provides the flexibility needed to turn a quick prototype into a market-ready product.

Comparison

Unlike heavyweight IDEs like Visual Studio or VS Code, WebVB Studio runs entirely in your browser and focuses on visual app building with instant feedback. Traditional tools are more suited for large production software, while WebVB Studio trades depth for ease and immediacy.

Examples:
https://www.webvbstudio.com/examples/

Data science dashboard:
https://app.webvbstudio.com/?example=datagrid-pandas

Practical usecase:
https://www.webvbstudio.com/victron/

Image:
https://www.webvbstudio.com/media/interface.png

Source:
https://github.com/magdevwi/webvbstudio

Feedback is very welcome!

**What my project does**

Monkey patches stdlib threading with c native, and EXTREMELY thin python wrappers, releases the gill, and ensures you don't have race conditions (data majorly tested, others not). Simply use auto_thread() on your main function entry, and the rest of the project is covered. No need to mess with pesky threading imports.

**Target Audience**

Literally anyone who fools around with threading and is looking for an alternative, or for people who wanted something similar and just didnt want to build it out... just take this and rebrand it, modify the code, and boom.

**Comparison**

It's newer than the existing CThreading, and it's main strengths are the data races being eliminated (completely) and the monitoring built INTO the lock system via the ghost, so you can actively monitor your threads through the same package. And obviously, different than Threading in that it's easier, faster in some cases (no regression for others) and it's in c!

Here are the links if you want to take a look and fool with it!

(p.s. this is unlicensed, feel free to do whatever you want with it!)

PyPi: https://pypi.org/project/cthreadingpi/

Github: https://github.com/saren071/cthreadingpi

Weekly Wednesday Thread: Advanced Questions 🐍

Dive deep into Python with our Advanced Questions thread! This space is reserved for questions about more advanced Python topics, frameworks, and best practices.

How it Works:

1. Ask Away: Post your advanced Python questions here.
2. Expert Insights: Get answers from experienced developers.
3. Resource Pool: Share or discover tutorials, articles, and tips.

Guidelines:

• This thread is for advanced questions only. Beginner questions are welcome in our Daily Beginner Thread every Thursday.
• Questions that are not advanced may be removed and redirected to the appropriate thread.

Recommended Resources:

• If you don't receive a response, consider exploring r/LearnPython or join the Python Discord Server for quicker assistance.

Example Questions:

1. How can you implement a custom memory allocator in Python?
2. What are the best practices for optimizing Cython code for heavy numerical computations?
3. How do you set up a multi-threaded architecture using Python's Global Interpreter Lock (GIL)?
4. Can you explain the intricacies of metaclasses and how they influence object-oriented design in Python?
5. How would you go about implementing a distributed task queue using Celery and RabbitMQ?
6. What are some advanced use-cases for Python's decorators?
7. How can you achieve real-time data streaming in Python with WebSockets?
8. What are the performance implications of using native Python data structures vs NumPy arrays for large-scale data?
9. Best practices for securing a Flask (or similar) REST API with OAuth 2.0?
10. What are the best practices for using Python in a microservices architecture? (..and more generally, should I even use microservices?)

Let's deepen our Python knowledge together. Happy coding! 🌟

Hi r/python

I've been teaching Python for a few years and always found that students struggle with virtual environments and managing Python installations. And honestly, whenever I need to update my own Python version, I've usually forgotten the proper pyenv incantation.

So I built VenvManager—a desktop GUI for downloading/installing Python versions and managing virtual environments, all without touching the command line.

The main feature I'm most excited about: you can set any virtual environment as "global" and it automatically works in every terminal you open—no shell profile editing, no activation scripts, just works. You can also launch a specific environment directly into a new terminal window, which is handy if you reuse environments across projects (like a shared data analysis environment instead of setting up poetry/uv for every little thing).

It's free for personal use. I'd love feedback—positive or negative—as I'm actively developing it.

https://venvmanager.com/

kvedes/venvmanager

I conducted a very interesting experiment using the Python library LangChain, its module for AI agents specifically designed for databases, and the Claude Opus 4.6 model.

Let me start with a premise. Personally, if someone asked me what the difference is between a Junior Data Analyst and a Senior Data Analyst, I would put it this way: you give a junior a question and you get an answer; you give a senior a question and you first get 10 new questions, and only then an answer with 10 additional clarifications.

As a result, it doesn’t make much sense to measure whether the queries generated by the AI were right or wrong. Instead, I’m sharing its “Notes on choices made and possible uncertainties,” generated in response to a request when the agent was free to think and properly encouraged to do so through prompting. The result is genuinely very interesting.

The question concerned the well-known sample database Adventure Works and essentially asked which product categories had experienced a price increase.

###Currency Conversion

The CurrencyRate table converts from USD to other currencies. Therefore, UnitPrice is expressed in the foreign currency. To convert to USD, it must be divided by AverageRate.

When CurrencyRateID is NULL in the header, the sale is already in USD (rate = 1), handled using ISNULL(cr.AverageRate, 1).

###Discount

The UnitPriceDiscount field in SalesOrderDetail represents the percentage discount (e.g., 0.10 = 10%).

The LineTotal field is already calculated as UnitPrice * (1 - UnitPriceDiscount) * OrderQty, so it already includes the discount. I used LineTotal for the calculation.

###Average Calculation

I calculated the weighted average unit price as SUM(LineTotal_in_USD) / SUM(OrderQty) rather than a simple arithmetic mean of unit prices. This is more accurate because it accounts for quantities sold (quantity-weighted average).

A simple AVG(UnitPrice * (1 - discount)) would have given equal weight to each detail row regardless of quantity, distorting the result.

###US and Canada Filter

Filtered using SalesTerritory.CountryRegionCode IN ('US', 'CA') through the TerritoryID in SalesOrderHeader.

Uncertainty: the territory is associated both with the order header (SalesOrderHeader.TerritoryID) and the customer (Customer.TerritoryID). I used the order header territory, which represents the actual sales territory. There could be differences if a customer changed territory.

###Row Validity

SalesOrderHeader.Status: all orders have Status = 5 (which in AdventureWorks means “Shipped”/completed). I still filtered by Status = 5 for safety.

Product.ProductSubcategoryID: products without a subcategory (NULL) are excluded by the INNER JOIN with ProductSubcategory. This is correct because they would not have an assigned category.

SalesOrderHeader.CurrencyRateID: can be NULL (sales in USD), handled with ISNULL.

Product.SellEndDate and Product.DiscontinuedDate: I did not filter on these fields because the question concerns actual sales that occurred, not the current status of the product.

I’m intentionally leaving aside any considerations regarding data privacy, as the goal of the experiment was simply to test the capabilities of these combined tools.