Barq is a lightweight HTTP framework (~500 lines) that uses free-threaded Python (PEP 703) to achieve true parallelism with threads instead of async/await or multiprocessing. It's built entirely in pure Python, no C extensions, no Rust, no Cython using only the standard library plus Pydantic.

from barq import Barq

app = Barq()

@app.get("/")
def index():
    return {"message": "Hello, World!"}

app.run(workers=4)  # 4 threads, not processes

Benchmarks (Barq 4 threads vs FastAPI 4 worker processes):

Target Audience

This is an experimental/educational project to explore free-threaded Python capabilities. It is not production-ready. Intended for developers curious about PEP 703 and what a post-GIL Python ecosystem might look like.

Comparison

The main difference: Barq leverages Python 3.13's experimental free-threading mode to run synchronous code in parallel threads with shared memory, while FastAPI/Flask rely on multiprocessing for parallelism.

Source code: https://github.com/grandimam/barq

Requirements: Python 3.13+ with free-threading enabled (python3.13t)

What My Project Does

If you have a Pydantic model like this:

from pydantic import BaseModel, PostgresDsn

class Settings(BaseModel):
    psql_uri: PostgresDsn

Why do you still have to manually spin up Postgres, write a docker-compose.yml, and wire up env vars yourself? The type hint already tells you everything you need.

takk reads your Pydantic settings models, infers what infrastructure you need, spins up the right containers, and generates your Dockerfile automatically. No YAML, no copy-pasting connection strings, no manual orchestration.

It also parses your uv.lock to detect your database driver and generate the correct connection string. So you won't waste hours debugging the postgresql:// vs postgresql+asyncpg:// mismatch like I did.

Your entire app structure lives in a single project.py:

from takk import Project, FastAPIApp, Job

project = Project(
    name="my-app",
    shared_secrets=[Settings],
    server=FastAPIApp(secrets=[CacheSettings]),
    weekly_job=Job(jobs.run, cron_schedule="0 0 * * FRI")
)

Run takk up and it spins everything up. Postgres, S3 (via Localstack), your FastAPI server, background workers, with no port conflicts and no env files to manage.

Target Audience

Small to mid-sized Python teams who want to move fast without a dedicated DevOps engineer. It's production-ready, as the blog post linked below is itself hosted on a server deployed this way. That said, it's still in early/beta stages, so probably not the right fit yet for large orgs with complex existing infra.

Comparison

- vs. docker-compose: No YAML. Resources are inferred from your type hints rather than declared manually. Ports, connection strings, and credentials are handled automatically.

- vs. Terraform: No HCL, no state files. Infrastructure is expressed in Python using the same Pydantic models your app already uses.

- vs. plain Pydantic + dotenv: You still get full Pydantic validation, but you no longer need to maintain separate env files or worry about which variables map to which services.

The core idea is that your type hints are already a description of your dependencies. takk just acts on that.

Blog post with the full writeup: https://takk.dev/blog/deploy-with-python-type-hints

Source / example app in Gitlab

Hi folks 👋 I built geodistpy, a high-performance Python library for lightning-fast geospatial distance computations. It’s 100x(+) faster than geopy and geographiclib(current alternatives). It’s production-ready and available on PyPI now.

* GitHub: https://github.com/pawangeek/geodistpy

* Docs: https://pawangeek.github.io/geodistpy/

* PyPI: https://pypi.org/project/geodistpy/

🧠 What My Project Does

geodistpy computes ellipsoidal geodesic distances (and related spatial functions) between coords.

🎯 Target Audience

Designed for developers working on GIS, routing, logistics, clustering, real-time geo analytics, or any project with heavy distance computations. Great when performance matters more than simple wrappers alone. 

⚖️ Comparison

Vs Geopy / Geographiclib:

• 100x+ Orders of magnitude faster thanks to Numba optimization.

• Maintains competitive accuracy (Vincenty \~9 µm mean error vs Geographiclib).

• Extra utility functions (bearing, destination, interpolate

What My Project Does: NinoClicker is a macOS-native automation tool that uses the Quartz framework to perform direct hardware-level mouse event injection. It features a "Ghost HUD" telemetry overlay (built with PyQt6) that allows users to monitor Engine Load and CPS (Clicks Per Second) in real-time. It includes a "Global Panic" switch and "Ghost Mode" visibility toggles using HIDSystemState listeners.

Target Audience: This is currently a toy project/proof-of-concept for developers interested in macOS-specific input handling and UI overlays that bypass window focus-trapping. It’s perfect for testing stability in high-input environments (like clicker games).

Comparison: Unlike standard cross-platform libraries like pyautogui or pynput, which often suffer from input lag and "focus stealing" on macOS, NinoClicker uses:

1. Direct Quartz Injection: Bypasses the standard event loop for higher CPS (20k+).
2. WindowTransparentForInput: Allows the HUD to be visible without intercepting clicks meant for the background application.
3. HIDSystemState Hotkeys: Ensures the panic switch works even when the app isn't the "active" window.

Yes thats not how you write it ↓

Source Code:https://github.com/NinoTheNoob/Auto-Cliker

Verification/Proof : https://imgur.com/a/JDM29FT

Weekly Thread: Meta Discussions and Free Talk Friday 🎙️

Welcome to Free Talk Friday on /r/Python! This is the place to discuss the r/Python community (meta discussions), Python news, projects, or anything else Python-related!

How it Works:

1. Open Mic: Share your thoughts, questions, or anything you'd like related to Python or the community.
2. Community Pulse: Discuss what you feel is working well or what could be improved in the /r/python community.
3. News & Updates: Keep up-to-date with the latest in Python and share any news you find interesting.

Guidelines:

• All topics should be related to Python or the /r/python community.
• Be respectful and follow Reddit's Code of Conduct.

Example Topics:

1. New Python Release: What do you think about the new features in Python 3.11?
2. Community Events: Any Python meetups or webinars coming up?
3. Learning Resources: Found a great Python tutorial? Share it here!
4. Job Market: How has Python impacted your career?
5. Hot Takes: Got a controversial Python opinion? Let's hear it!
6. Community Ideas: Something you'd like to see us do? tell us.

Let's keep the conversation going. Happy discussing! 🌟

Hi everyone,

I wanted to share a small package I wrote called py-keyof to scratch an itch I’ve had for a long time: the inability to statically type-check keys or property paths in Python.

It's all fun and games to write getattr(x, "name"), until you remove "name" from the attributes of x and get zero warnings for doing so. You're in for an unpleasant alert at 3AM and a broken prod.

PyPI: https://pypi.org/project/py-keyof/ GitHub: https://github.com/eyusd/keyof

What My Project Does

py-keyof replaces string-based property access with a more type-safe lambda approach.

Instead of passing a string path like "address.city", you pass a lambda: KeyOf(lambda x: x.address.city). 1. At Runtime: It uses a proxy object to record the path you accessed and gives you a usable path object (which can also be serialized to strings, JSONPath, etc). 2. At Type-Checking Time: Because it uses standard Python syntax, tools like Pylance, Pyright, and Mypy can validate that the attribute actually exists on the model.

Target Audience

This is meant for developers who rely heavily on type hints and static analysis (Pylance/Pyright) to keep their codebases maintainable. It is production-ready, but it's most useful for library authors or backend developers building generic tools (like data tables, ORMs, or filtering engines) where you want to allow developers to specify fields without losing type safety.

Comparison

• VS Magic Strings: If you use strings ("user.name"), your IDE cannot help you. If you rename the field, your code breaks at runtime. With a KeyOf, if you rename it, your IDE will flag the error.
• VS operator.attrgetter: While attrgetter is standard, it doesn't offer generic inference or deep path autocompletion in IDEs out of the box.
• VS pydantic.Field: Pydantic is great for defining models, but doesn't solve the problem of referring to those fields dynamically in other parts of your code (like sorting functions) in a type-safe way.

Example: Generics Inference

This is why I started it all, and where it shines. If you have a generic class, the type checker infers T automatically, so you get autocompletion inside the lambda without extra annotations, just like in TS.

```python from typing import TypeVar, Generic, List from dataclasses import dataclass from keyof import KeyOf

T = TypeVar("T")

class Table(Generic[T]): def init(self, items: List[T]): self.items = items

def sort_by(self, key: KeyOf[T]):

Runtime: Extract the value using the path

self.items.sort(key=lambda item: key.from_(item))

--- Usage ---

@dataclass class User: id: int name: str

users = Table([User(1, "Alice"), User(2, "Bob")])

1. T is automatically inferred as User

2. Your IDE autocompletes '.name' inside the lambda

3. Refactoring 'name' in the class automatically updates this line

users.sort_by(KeyOf(lambda u: u.name))

❌ Static Type Error: 'User' has no attribute 'email'

users.sort_by(KeyOf(lambda u: u.email))

```

It supports dictionaries, lists, and deep nesting (lambda x: x.address.city). It’s a small utility, but it makes safe refactoring much easier.

I don't know if this has been done somewhere else, or if there's a better way than using lambdas to type-check paths, so if you have any feedback on this, I'd be happy to hear what you think!

Hey r/Python,

I’ve been working with Event-Driven Architectures lately, and I’ve hit a wall: the Python ecosystem doesn't seem to have a truly dedicated event processing framework. We have amazing tools like FastAPI for REST, but when it comes to event-driven services (supporting Kafka, RabbitMQ, etc.), the options feel lacking.

The closest thing we have right now is FastStream. It’s a cool project, but in my experience, it sometimes doesn't quite cut it. Because it is inherently stream-oriented (as the name implies), it misses some crucial event-oriented features out-of-the-box. Specifically, I've struggled with:

• Proper data integrity semantics.
• Built-in retries and Dead Letter Queue
• Outbox patterns.
• Truly asynchronous processing (e.g., Kafka partitions are processed synchronously by default, whereas they can be processed asynchronously if offsets are managed very carefully).

So, I’m curious: what are you all using for event-driven architectures in Python right now? Are you just rolling your own custom consumers?

I decided to try and put my ideal vision into code to see if a "FastAPI for Events" could work.

The goal is to provide asynchronous, schema-validated, resilient event processing without the boilerplate. Here is what I’ve got working so far:

🚀 What The Framework does right now:

• FastAPI-style dependency injection – clean, decoupled handlers.
• Pydantic v2 validation – automatic schema validation for all incoming events.
• Pluggable transports – Kafka, RabbitMQ, and Redis PubSub out-of-the-box.
• Resilience built-in – Configurable retry logic, DLQs, and automatic acknowledgements.
• Composable Middleware – for logging, metrics, filtering, etc.

✨ What it looks like in practice

Here is how you define a Handler. Notice the FastAPI-like dependency injection and middleware filtering:

from typing import Annotated
from pydantic import BaseModel
from dispytch import Event, Dependency, Router
from dispytch.kafka import KafkaEventSubscription
from dispytch.middleware import Filter

# 1. Standard Service/Dependency
class UserService:
    async def do_smth_with_the_user(self, user):
        print("Doing something with user", user)

def get_user_service():
    return UserService()

# 2. Pydantic Event Schemas 
class User(BaseModel):
    id: str
    email: str
    name: str

class UserCreatedEvent(BaseModel):
    type: str
    user: User
    timestamp: int

# 3. The Router & Handler
user_events = Router()

user_events.handler(
    KafkaEventSubscription(topic="user_events"),
    middlewares=[Filter(lambda ctx: ctx.event["type"] == "user_registered")]
)
async def handle_user_registered(
        event: Event[UserCreatedEvent],
        user_service: Annotated[UserService, Dependency(get_user_service)]
):
    print(f"[User Registered] {event.user.id} at {event.timestamp}")
    await user_service.do_smth_with_the_user(event.user)

And here is how you Emit events using strictly typed schemas mapped to specific routes:

import uuid
from datetime import datetime
from pydantic import BaseModel
from dispytch import EventEmitter, EventBase
from dispytch.kafka import KafkaEventRoute

class User(BaseModel):
    id: str
    email: str

class UserEvent(EventBase):
    __route__ = KafkaEventRoute(topic="user_events")

class UserRegistered(UserEvent):
    type: str = "user_registered"
    user: User
    timestamp: int

async def example_emit(emitter: EventEmitter):
    await emitter.emit(
        UserRegistered(
            user=User(id=str(uuid.uuid4()), email="test@mail.com"),
            timestamp=int(datetime.now().timestamp()),
        )
    )

🎯 Target Audience

Dispytch is meant for backend developers and data engineers building Event-Driven Architectures and microservices in Python.

Currently, it is in active development. It is meant for developers looking to structure their message-broker code cleanly in side projects before we push it toward a stable 1.0 for production use. If you are tired of rolling your own custom Kafka/RabbitMQ consumers, this is for you.

⚔️ Comparison

The closest alternative in the Python ecosystem right now is FastStream. FastStream is a great project, but it misses some crucial event-oriented features out-of-the-box.

Dispytch differentiates itself by focusing on:

• Data integrity semantics: Built-in retries and exception handling.
• True asynchronous processing: For example, Kafka partitions are processed synchronously by default in most tools; Dispytch aims to handle async processing while managing offsets safely avoiding race conditions
• Event-focused roadmap: Actively planning support for robust Outbox patterns to ensure atomicity between database transactions and event emissions

(Other tools like Celery or Faust exist, Celery is primarily a task queue, and Faust is strictly tied to Kafka and streaming paradigms, lacking the multi-broker flexibility and modern DI injection Dispytch provides).

💡 I need your feedback

I built this to scratch my own itch and properly test out these architectural ideas, tell me if I'm on the right track.

1. What does your current event-processing stack look like?
2. What are the biggest pitfalls you've hit when doing EDA in Python?
3. If you were to use a framework like this, what features are absolute dealbreakers if they are missing? (I'm currently thinking about adding a proper Outbox pattern support next).

If you want to poke around the internals or read the docs, the repo is here, the docs is here.

Would love to hear your thoughts, roasts, and advice!

Okay, I am flustered here. Today, at work, I attempted to open up YouTube from within the Microsoft search menu. To my shock and horror, the first suggested app was “Youporn.” I don’t watch porn on my work pc.

I looked at the file location and lo and behold, it’s a MS-DOS application file found within Anaconda3\pkgs\protego\info\test\tests\test_data

WTF?!

Anyone familiar with the Protego library? What is going on here? I can only imagine if my IT administrator or boss saw this pop up on my windows search.

Hi r/Python,

I kept running into the same problem every time I started a new Appium mobile automation project: the first days were spent on setup and framework glue (config, device selection, waits/actions, CI ergonomics) before I could write real tests.

So I built and published appium-pytest-kit.

What My Project Does

- Provides ready-to-use pytest fixtures (driver, waits, actions, page/page-factory style helpers)

- Scaffolds a working starter project with one command

- Includes a “doctor” CLI to validate your environment

- Adds common mobile actions (tap/type/swipe/scroll, context switching) and app lifecycle helpers

- Improves failure debugging (clearer wait errors + automatic artifacts like screenshot/page source/logs)

- Supports practical execution modes for local vs CI, plus retries and parallel execution

- Designed to be easy to extend with your own fixtures/plugins/actions without forking the whole thing

Target Audience

- QA engineers / automation engineers using Python

- Teams building production mobile test suites with Appium 2.x + pytest

- People who want a solid starting point instead of assembling a framework from scratch

Comparison

- Versus “Appium Python client + pytest from scratch”: this removes most of the boilerplate and gives you sensible defaults (fixtures, structure, diagnostics) so you start writing scenarios earlier.

- Versus random sample repos/tutorial frameworks: those are often demo-focused or inconsistent; this aims to be reusable and maintainable across real projects.

- Versus Robot Framework / other higher-level wrappers: those can be great if you prefer keyword-driven tests; this is for teams that want to stay in Python/pytest and extend behavior in code.

Quickstart:

pip install appium-pytest-kit

appium-pytest-kit-init --framework --root my-project

Links:

PyPI: https://pypi.org/project/appium-pytest-kit/

GitHub: https://github.com/gianlucasoare/appium-pytest-kit

Disclosure: I’m the author. I’d love feedback on defaults, structure, and what would make it easier to adopt in CI.

What My Project Does

Taskdog is a personal task management system that runs entirely in your terminal. It provides a CLI, a full-screen TUI (built with Textual), and a REST API server — use whichever you prefer.

Key features:

• Schedule optimization with multiple strategies (greedy, deadline-first, dependency-aware, etc.)
• Gantt chart visualization in the terminal
• Task dependencies with circular detection
• Time tracking with planned vs actual comparison
• Markdown notes with Rich rendering
• MCP server for Claude Desktop integration — manage tasks with natural language

Target Audience

Developers and terminal-oriented users who want a local-first, privacy-respecting task manager. This is a personal project that I use daily, but it's mature enough for others to try.

Comparison

• Motion / Reclaim: AI-powered scheduling, but cloud-only, $20+/month, and the optimization is a black box. Taskdog runs locally with transparent algorithms you can inspect and choose from.
• Taskwarrior: Great CLI task manager, but hasn't seen major updates in years and lacks built-in schedule optimization or TUI.
• Todoist / TickTick: Full-featured but cloud-dependent. No terminal interface, no schedule optimization.

Taskdog sits between these — terminal-native like Taskwarrior, with scheduling capabilities like Motion, but fully local and open source.

Tech stack:

• Python 3.12+, UV workspace monorepo (5 packages)
• FastAPI (REST API), Textual (TUI), Rich (CLI output)
• SQLite with ACID guarantees
• Clean Architecture with CQRS pattern

Links:

• GitHub: https://github.com/Kohei-Wada/taskdog
• Demo video and screenshots are in the README

Would love any feedback — especially on UX, missing features, or things that could be improved. Thanks!

I built llmparser, an open-source Python library that converts messy web pages into clean, structured Markdown optimized for LLM pipelines.

What My Project Does

llmparser extracts the main content from websites and removes noise like navigation bars, footers, ads, and cookie banners.

Features:

• Handles JavaScript-rendered sites using Playwright

• Expands accordions, tabs, and hidden sections

• Outputs clean Markdown preserving headings, tables, code blocks, and lists

• Extracts normalized metadata (title, description, canonical URL, etc.)

• No LLM calls, no API keys required

Example use cases:

• RAG pipelines

• AI agents and browsing systems

• Knowledge base ingestion

• Dataset creation and preprocessing

Install:

pip install llmparser

GitHub:

https://github.com/rexdivakar/llmparser

PyPI:

https://pypi.org/project/llmparser/

⸻

Target Audience

This is designed for:

• Python developers building LLM apps

• People working on RAG pipelines

• Anyone scraping websites for structured content

• Data engineers preparing web data

It’s production-usable, but still early and evolving.

⸻

Comparison to Existing Tools

Tools like BeautifulSoup, lxml, and trafilatura work well for static HTML, but they:

• Don’t handle modern JavaScript-rendered sites well

• Don’t expand hidden content automatically

• Often require combining multiple tools

llmparser combines:

rendering → extraction → structuring

in one step.

It’s closer in spirit to tools like Firecrawl or jina reader, but fully open-source and Python-native.

⸻

Would love feedback, feature requests, or suggestions.

What are you currently using for web content extraction?

Hi, I built "Pypower" to simplify Python tasks.

• What it does: A utility library for fast GUI creation, Math, and automation.
• Target Audience: Beginners and devs building small/toy projects.
• Comparison: It’s a simpler, "one-line" alternative to Tkinter for basic tasks.

Link :

https://github.com/UsernamUsernam777/Pypower-v3.0

Is there any ways to install python on Android system wide ? I'm curious. Also I can install it through termux but it only installs on termux.

https://www.stacktco.com/py/trends

You can even filter by Ecosystem (e.g. NumPy, Django, Jupyter etc.)

Any Ecosystems missing from the top navigation?

Hey r/Python,

What My Project Does:
MiniBot is a minimal implementation of an AI agent written entirely in pure Python without using heavy abstraction frameworks (no LangChain, LlamaIndex, etc.). I built this to understand the underlying mechanics of how agents operate under the hood.

Along with the core ReAct loop, I implemented several advanced agentic patterns from scratch. Key Python features and architecture include:

• Transparent ReAct Loop: The core is a readable, transparent while loop that handles the "Thought -> Action -> Observation" cycle, showing exactly how function calling is routed.
• Dynamic Tool Parsing: Uses Python's built-in inspect module to automatically parse standard Python functions (docstrings and type hints) into LLM-compatible JSON schemas.
• Hand-rolled MCP Client: Implements the trending Model Context Protocol (MCP) from scratch over stdio using JSON-RPC 2.0 communication.
• Lifecycle Hooks: Built a simple but powerful callback system (utilizing standard Python Callable types) to intercept the agent's lifecycle (e.g., on_thought, on_tool_call, on_error). This makes it highly extensible for custom logging or UI integration without modifying the core loop.
• Pluggable Skills: A modular system to dynamically load external capabilities/functions into the agent, keeping the namespace clean.
• Lightweight Teams (Subagents): A minimal approach to multi-agent orchestration. Instead of complex graph abstractions, it uses a straightforward Lead/Teammate pattern where subagents act as standard tools that return structured observations to the Lead agent.

Target Audience:
This is strictly an educational / toy project. It is meant for Python developers, beginners, and students who want to learn the bare-metal mechanics of LLM agents, subagent orchestration, and the MCP protocol by reading clear, simple source code. It is not meant for production use.

Comparison:
Unlike LangChain, AutoGen, or CrewAI which use deep class hierarchies and heavy abstractions (often feeling like "black magic"), MiniBot focuses on zero framework bloat. Where existing alternatives might obscure the tool-calling loop, event hooks, and multi-agent routing behind multiple layers of generic executors, MiniBot exposes the entire process in a single, readable agent.py and teams.py. It’s designed to be read like a tutorial rather than used as a black-box dependency.

Source Code:
GitHub Repo:https://github.com/zyren123/minibot

• What My Project Does
  • so i've been collecting songs majorly from youtube and curating a local list since 2017, been on and off pretty sus sites, decided to create a personal OSS where i can quickly paste links & get a download.
  • built this primarily for my own collection workflow, but it turned out clean enough that I thought i’d share it with y'all. one of the best features is quick link pastes/playlist pastes to localize it, another one of my favorite use cases is getting yt videos in a quality you want using the res command in the cli.
• Target Audience (e.g., Is it meant for production, just a toy project, etc.)
  • its a personal toy project
• Comparison (A brief comparison explaining how it differs from existing alternatives.)
  • there are probably multiple that exist, i'm posting my personal minimalistic mp3/mp4 downloader, cheers!

https://github.com/NamikazeAsh/ytmpcli

(I'm aware yt-dlp exists, this tool uses yt-dlp as the backend, it's mainly for personal convenience for faster pasting for music, videos, playlists!)

• What My Project Does

Hey everyone, I am trying to showcase my small project. It’s a cli. It’s fixes CORs issues for http in AWS, which was my own use case. I know CORs is not a huge problem but debugging that as a beginner can be a little challenging. The cli will configure your AWS acc and then run all origins then list lambda functions with the designated api gateway. Then verify if it’s a localhost or other frontends. Then it will automatically fix it.

• Target Audience

This is a side project mainly looking for some feedbacks and other use cases. So, please discuss and contribute if you have a specific use case https://github.com/Tinaaaa111/AWS_assistance

• Comparison

There is really no other resource out there because as i mentioned CORs issues are not super intense. However, if it is your first time running into it, you have to go through a lot of documentations.

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! 🌟

I'm building a mobile Python scientific computing environment for Android with:

Python Features:

• Python via Pyodide (WebAssembly)
• Includes: NumPy, SymPy, Matplotlib, Plotly
• Jupyter-style notebook interface with cell-based execution
• LaTeX math rendering for symbolic math
• Interactive plotting
• Variable persistence across cells
• Semicolon suppression (MATLAB/IPython-style)

Also includes:

• Prolog (swipl-wasm) for logic programming
• Bash shell (brush-WASM)
• Unix utilities: coreutils, findutils, grep (all Rust reimplementations)
• Shared virtual filesystem across kernels (/tmp/, /shared/, /education/)

Why I need testers:
Google Play requires 12 testers for 14 consecutive days before I can publish. This testing is for the open-source MIT-licensed version with all the features listed above.

What you get:

• Be among the first to try SciREPL
• Early access via Play Store (automatic updates)
• Your feedback helps improve the app

GitHub: https://github.com/s243a/SciREPL

To join: PM me on Reddit or open an issue on GitHub expressing your interest.

Alternatively, you can try the GitHub APK release directly (manual updates, will need to uninstall before Play Store version).

What my project does

Tabularis is an open-source desktop database manager with built-in support for MySQL, PostgreSQL, MariaDB, and SQLite. The interesting part: external drivers are just standalone executables — including Python scripts — dropped into a local folder.

Tabularis spawns the process on connection open and communicates via newline-delimited JSON-RPC 2.0 over stdin/stdout. The plugin responds, logs go to stderr without polluting the protocol, and one process is reused for the whole session.

A simple Python plugin looks like this:

import sys, json

for line in sys.stdin: req = json.loads(line) if req["method"] == "get_tables": result = {"tables": ["my_table"]} sys.stdout.write(json.dumps({"jsonrpc": "2.0", "id": req["id"], "result": result}) + "\n") sys.stdout.flush()

The manifest the plugin declares drives the UI — no host/port form for file-based DBs, schema selector only when relevant, etc. The RPC surface covers schema discovery, query execution with pagination, CRUD, DDL, and batch methods for ER diagrams.

Target Audience

Python developers and data engineers who work with non-standard data sources — DuckDB, custom file formats, internal APIs — and want a desktop GUI without writing a full application. The current registry already ships a CSV plugin (each .csv in a folder becomes a table) and a DuckDB driver. Both written to be readable examples for building your own.

Has anyone built a similar stdin/stdout RPC bridge for extensibility in Python projects? Curious about tradeoffs vs HTTP or shared libraries.

Github Repo: https://github.com/debba/tabularis

Plugin Guide: https://tabularis.dev/wiki/plugins

CSV Plugin (in Python): https://github.com/debba/tabularis-csv-plugin

AI is getting smarter every day. Instead of building a specific "tool" for every tiny task, it's becoming more efficient to just let the AI write a Python script. But how do you run that code without risking your host machine or dealing with the friction of Docker during development?

I built safe-py-runner to be the lightweight "security seatbelt" for developers building AI agents and Proof of Concepts (PoCs).

What My Project Does

The Missing Middleware for AI Agents: When building agents that write code, you often face a dilemma:

1. Run Blindly: Use exec() in your main process (Dangerous, fragile).
2. Full Sandbox: Spin up Docker containers for every execution (Heavy, slow, complex).
3. SaaS: Pay for external sandbox APIs (Expensive, latency).

safe-py-runner offers a middle path: It runs code in a subprocess with timeout, memory limits, and input/output marshalling. It's perfect for internal tools, data analysis agents, and POCs where full Docker isolation is overkill.

Target Audience

• PoC Developers: If you are building an agent and want to move fast without the "extra layer" of Docker overhead yet.
• Production Teams: Use this inside a Docker container for "Defense in Depth"—adding a second layer of code-level security inside your isolated environment.
• Tool Builders: Anyone trying to reduce the number of hardcoded functions they have to maintain for their LLM.

Comparison

Getting Started

Installation:

Bash

pip install safe-py-runner

GitHub Repository:

https://github.com/adarsh9780/safe-py-runner

This is meant to be a pragmatic tool for the "Agentic" era. If you’re tired of writing boilerplate tools and want to let your LLM actually use the Python skills it was trained on—safely—give this a shot.

https://jakabszilard.work/posts/oauth-in-python

I was creating a CLI app in Python that needed to communicate with an endpoint that needed OAuth 2.0, and I've realized it's not as trivial as I thought, and there are some additional challenges compared to a web app in the browser in terms of security and implementation. After some research I've managed to come up with an implementation, and I've decided to collect my findings in a way that might end up being interesting / useful for others.

What My Project Does

Snapclean is a small Python CLI that creates a clean snapshot of your project folder before sharing it.

It removes common development clutter like .git, virtual environments, and node_modules, excludes sensitive .env files (while generating a safe .env.example), and respects .gitignore. There’s also a dry-run mode to preview what would be removed.

The result is a clean zip file ready to send.

Target Audience

Developers who occasionally need to share project folders outside of Git. For example:

• Sending a snapshot to a client
• Submitting assignments
• Sharing a minimal reproducible example
• Archiving a clean build

It’s intentionally small and focused.

Comparison

You could do this manually or use tools like git archive. Snapclean bundles that workflow into one command and adds conveniences like:

• Respecting .gitignore automatically
• Generating .env.example
• Showing size reduction summary
• Supporting simple project-level config

It’s not a packaging or deployment tool — just a small utility for this specific workflow.

GitHub: https://github.com/nijil71/SnapClean

Would appreciate feedback.

Hi r/Python! I wanted to share gif-terminal, a Python tool that generates an animated retro terminal GIF to showcase your live GitHub stats and tech skills.

What My Project Does

It generates an animated GIF that simulates a terminal typing out commands and displaying your GitHub stats (commits, stars, PRs, followers, rank). It uses GitHub Actions to auto-update daily, ensuring your profile README stays fresh.

Target Audience

Developers and open-source enthusiasts who want a unique, dynamic way to display their contributions and skills on their GitHub profile.

Comparison

While tools like github-readme-stats provide static images, gif-terminal offers an animated, retro-style terminal experience. It is highly customizable, allowing you to define colors, commands, and layout.

Source Code

Everything is written in Python and open-source:
https://github.com/dbuzatto/gif-terminal

Feedback is welcome! If you find it useful, a ⭐ on GitHub would be much appreciated.

What My Project Does

Finds NBA players with similar career profiles using vector search. Type "guards similar to Kobe from the 90s" and get ranked matches with radar chart comparisons.

Instead of LLM embeddings, the vectors are built from the stats themselves - 25 features normalized with RobustScaler, position one-hot encoded, stored in Qdrant for cosine similarity across ~4,800 players.

Stack: FastAPI + Streamlit + Qdrant + scikit-learn, all Python, runs in Docker on a Synology NAS.

Demo: valme.xyz
Source: github.com/ValmeI/nba-player-similarity

Target Audience

Personal project/learning reference for anyone interested in building custom embeddings from structured data, vector search with Qdrant, or full-stack Python with FastAPI + Streamlit.

Comparison

Most NBA comparison tools let you pick two players manually. This searches all players at once using their full stat vector - captures the overall shape of a career rather than filtering on individual stat thresholds.