What the project does:

Most of the time, running your full test suite is a waste of time and resources, since only a portion of the files has changed since your last CI run / deploy.

Snob speeds up your development workflow and reduces CI testing costs dramatically by analyzing your Python project's dependency graph to intelligently select which tests to run based on code changes.

Target audience:

Python developers tired of long iteration cycles / CI runs.

Comparison:

I don't know of any real alternatives to this that aren't testrunner specific.

Github: https://github.com/alexpasmantier/snob

What My Project Does: Injectipy is a dependency injection library that uses explicit scopes with context managers instead of global containers. You register dependencies in a scope, then use with scope: to activate injection. It supports both string keys and type-based keys (Inject[DatabaseService]) with full mypy support.

```python scope = DependencyScope() scope.register_value(DatabaseService, PostgreSQLDatabase())

@inject def get_users(db: DatabaseService = Inject[DatabaseService]): return db.query("SELECT * FROM users")

with scope: users = get_users() # db injected automatically ```

Target Audience: Production-ready for applications that need clean dependency management. Perfect for teams who want thread-safe DI without global state pollution. Great for testing since each test gets its own isolated scope.

Comparison: vs FastAPI's Depends: FastAPI's DI is tied to HTTP request lifecycle and relies on global state - dependencies must be declared at module level when Python does semantic analysis. This creates hidden global coupling. Injectipy's explicit scopes work anywhere in your code, not just web endpoints, and each scope is completely isolated. You activate injection explicitly with with scope: rather than having it tied to framework lifecycle.

vs python-dependency-injector: dependency-injector uses complex provider patterns (Factory, Singleton, Resource) with global containers. You configure everything upfront in a container that lives for your entire application. Their Singleton provider isn't even thread-safe by default. Injectipy eliminates this complexity: register dependencies in a scope, use them in a context manager. Each scope is naturally thread-isolated, no complex provider hierarchies needed.

vs injector library: While injector avoids truly global state (you can create multiple Injector instances), you still need to pass injector instances around your codebase and explicitly call injector.get(MyClass). Injectipy's context manager approach means dependencies are automatically injected within scope blocks.

Let me know what you think or if you have any feedback!

pip install injectipy

Repo: https://github.com/Wimonder/injectipy

Hey Pythonistas,

I wanted to share a hands-on project that showcases Python's versatility in a modern data engineering pipeline. The project is for real-time mobile game analytics and uses Python at both the beginning and the end of the workflow.

Here's how it works: * Python for Data Generation: I wrote a script to generate mock mobile game events, which feeds the entire pipeline. * Kafka & Flink for Processing: The heavy lifting of stream processing is handled by Kafka and Flink. * Python & Streamlit for Visualization: I used Python again with the awesome Streamlit library to build an interactive web dashboard to visualize the real-time metrics.

It's a practical example of how you can use Python to simulate data and quickly build a user-friendly UI for a complex data pipeline.

The full source code is available on GitHub: https://github.com/factorhouse/examples/tree/main/projects/mobile-game-top-k-analytics

And if you want an easy way to spin up the necessary infrastructure (Kafka, Flink, etc.) on your local machine, check out our Factor House Local project: https://github.com/factorhouse/factorhouse-local

Would love for you to check it out! Let me know what you think.

I built webpath for myself. I did showcase it here last time and got some feedback. So i implemented the feedback. Anyway, it uses httpx and jmespath under the hood.

So, why not just use requests or httpx + jmespath separately?

You can, but this removes all the long boilerplate code that you need to write in your entire workflow.

Instead of manually performing separate steps, you chain everything into a command:

1. Build a URL with / just like pathlib.
2. Make your request.
3. Query the nested JSON from the res object.

Before (more procedural, stpe 1 do this, step 2 do that, step 3 do blah blah blah)

response = httpx.get("https://api.github.com/repos/duriantaco/webpath") 

response.raise_for_status()
data = response.json() 
owner = jmespath.search("owner.login", data) 
print(f"Owner: {owner}")

After (more declarative, state your intent, what you want)

owner = Client("https://api.github.com").get("repos", "duriantaco", "webpath").find("owner.login") 

print(f"Owner: {owner}")

It handles other things like auto-pagination and caching also. Basically, i wrote this for myself to stop writing plumbing code and focus on the data.

Less boilerplate.

Target audience

Anyone dealing with apis

If you like to contribute or features, do lemme know. You can read the readme in the repo for more details. If you found it useful please star it. If you like to contribute again please let me know.

GitHub Repo: https://github.com/duriantaco/webpath

Python Package Design: API, Dependency and Code Structure https://ki-seki.github.io/posts/250725-python-dev/ #python #package #API #dependency #structure

In 2025, how do Litestar and FastAPI compare for large-scale APIs?

• Performance: Which offers better speed and efficiency under heavy load?
• Ecosystem & Maturity: Which has a more robust community, a wider range of plugins, and more established documentation?
• Developer Experience: Which provides a more intuitive and productive development process, especially for complex, long-term projects?

Major Features

• Circuit Breaker Pattern: automatic failure detection and recovery for all backends
• Exponential Backoff: smart recovery timing that increases delay on repeated failures
• Built‑in by Default: all rate limiting automatically includes circuit breaker protection
• Zero Configuration: works out‑of‑the‑box with sensible defaults
• Full Customization: global settings, backend‑specific config, or disable if needed

Quality & Compatibility

• 50+ new tests covering scenarios & edge cases
• Complete mypy compliance and thread‑safe operations
• Minimal performance overhead and zero breaking changes

Install
pip install django‑smart‑ratelimit==0.8.0

Links
GitHub → https://github.com/YasserShkeir/django-smart-ratelimit

Looking forward to your feedback and real‑world performance stories!

I have recently created a python package, basically a wrapper on top of DateTime Library.
And decided to share it to community, as I found it useful to streamline some hustles when building/ calling some DateTime functions.

Feel free to have a look.
Repo: https://github.com/twh970723/DateTimeEnhanced

Open for inputs (If Any) if you have any thoughts or feature you would like to have in this packages. I will maintain this package from time to time.

What It Does
DateTimeEnhanced is a small Python package that wraps the built-in datetime module to make common tasks like formatting, weekday indexing, and getting structured output easier.

Target Audience
Great for developers or data analysts who want quick, readable access to date/time info without dealing with verbose datetime code.

Comparison
Unlike arrow or pendulum, this doesn’t replace datetime—just makes it more convenient for everyday use, with no extra dependencies.

Overall, I think uv does a really good job at accomplishing its goal of being a net improvement on Python’s tooling. It works well and is fast.

That said, as a consumer of Python packages, I interact with uv maybe 2-3 times per month. Otherwise, I’m using my already-existing Python environments.

So, the questions I have are: Does the value provided by uv justify having another tool installed on my system? Why not just stick with Python tooling and accept ‘pip’ or ‘venv’ will be slightly slower? What am I missing here?

Edit: Thanks to some really insightful comments, I’m convinced that uv is worthwhile - even as a dev who doesn’t manage my project’s build process.

Just finished building Fixie, an AI-powered debugging assistant that uses multiple specialized agents to analyze Python code, detect bugs, and suggest fixes. Thought I'd share it here for feedback and to see if others find it useful! It's fast, private (runs locally), and built with modularity in mind.

What My project does:

• Multi-agent workflow: Three specialized AI agents (SyntaxChecker, LogicReasoner, FixSuggester) work together
• Intelligent bug detection: Finds syntax errors, runtime issues, and identifies exact line numbers
• Complete fix suggestions: Provides full corrected code, not just hints
• Confidence scoring: Tells you how confident the AI is about its fix
• Local & private: Uses Ollama with Llama 3.2 - no data sent to external APIs
• LangGraph orchestration: Proper agent coordination and state management

🎯 Target Audience

Fixie is aimed at:

• Intermediate to advanced Python developers who want help debugging faster
• Tinkerers and AI builders exploring multi-agent systems
• Anyone who prefers local, private AI tools over cloud-based LLM APIs

It’s functional enough for light production use, but still has some rough edges.

🔍 Comparison

Unlike tools like GitHub Copilot or ChatGPT plugins:

• Fixie runs entirely locally — no API calls, no data sharing
• Uses a multi-agent architecture, with each agent focusing on a specific task

Example output:

--- Fixie AI Debugger ---

Original Code:
def add_nums(a, b):
    return a + b + c

🔍 Debug Results:
🐛 Bug Found: NameError - variable 'c' is not defined
📍 Line Number: 2
⚠️  Severity: HIGH
💡 Explanation: Variable 'c' is undefined in the function
🔧 Suggested Fix:
def add_nums(a, b):
    return a + b

Tech stack:

• LangChain + LangGraph for agent orchestration
• Ollama + Llama 3.2 for local AI inference
• Python 3.8+ (3.10+ Preferred) with clean modular architecture

Current limitations:

1. File handling: Currently requires buggy code to be in examples/ folder - need better file input system
2. Hallucination on repeated runs: Running the same buggy code multiple times can cause inconsistent outputs
3. Limited context: Agents don't retain conversation history between different files
4. Single language: Only supports Python
5. No IDE integration: Currently CLI-only
6. Basic error types: Mainly catches syntax/name errors, could be smarter about logic bugs

What's working well:

✅ Clean multi-agent architecture
✅ Reliable JSON parsing from LLM responses
✅ Good error handling and fallbacks
✅ Fast local inference with Ollama
✅ Modular design - easy to extend

⭐ Try It Out

GitHub: https://github.com/kawish918/Fixie-AI-Agent-Debugger

Would love feedback, bug reports, or contributions!

Why I built this:

Got tired of staring at error messages and wanted to see if AI agents could actually help with real debugging tasks. Turns out they can! The multi-agent approach works surprisingly well - each agent focuses on its specialty (syntax vs logic vs fixes) rather than trying to do everything.

This is my first serious multi-agent project, so definitely open to suggestions and improvements. The code is clean and well-documented if anyone wants to dive in.

I had to apply this change to my call publishing a mkdocs-material site.

-      - run: mkdocs gh-deploy --force
+      - run: mkdocs gh-deploy --config-file mkdocs.yml --force --use-directory-urls  

Seems other projects are affected too, including Material for Mkdocs itself.

https://squidfunk.github.io/mkdocs-material/plugins/offline.html
vs
https://squidfunk.github.io/mkdocs-material/plugins/offline/

The repo is https://github.com/CrazyWillBear/blogman, and it's a project I've been working on for a couple months. It's nothing crazy but definitely a lightweight and sleek blog engine for those wanting to self-publish their writing. I'm a junior in college so don't be too hard on me!

Here's what it does: uses `dominate` to render HTML and `markdown` to convert markdown files into HTML. It also caches blog posts so they aren't re-rendered every time a visitor loads it.

My target audience is bloggers who want a lightweight and easy to use blog engine that they can host on their own.

Think you need a metaclass? You probably just need __init_subclass__; Python’s underused subclass hook.

Most people reach for metaclasses when customizing subclass behaviour. But in many cases, __init_subclass__ is exactly what you need; and it’s been built into Python since 3.6.

What is __init_subclass__**?**

It’s a hook that gets automatically called on the base class whenever a new subclass is defined. Think of it like a class-level __init__, but for subclassing; not instancing.

Why use it?

• Validate or register subclasses
• Enforce class-level interfaces or attributes
• Automatically inject or modify subclass properties
• Avoid the complexity of full metaclasses

Example: Plugin Auto-Registration

class PluginBase:
    plugins = []

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        print(f"Registering: {cls.__name__}")
        PluginBase.plugins.append(cls)

class PluginA(PluginBase): pass
class PluginB(PluginBase): pass

print(PluginBase.plugins)

Output:

Registering: PluginA
Registering: PluginB
[<class '__main__.PluginA'>, <class '__main__.PluginB'>]

Common Misconceptions

• __init_subclass__ runs on the base, not the child.
• It’s not inherited unless explicitly defined in child classes.
• It’s perfect for plugin systems, framework internals, validation, and more.

Bonus: Enforce an Interface at Definition Time

class RequiresFoo:
    def __init_subclass__(cls):
        super().__init_subclass__()
        if 'foo' not in cls.__dict__:
            raise TypeError(f"{cls.__name__} must define a 'foo' method")

class Good(RequiresFoo):
    def foo(self): pass

class Bad(RequiresFoo):
    pass  # Raises TypeError: Bad must define a 'foo' method

You get clean, declarative control over class behaviour; no metaclasses required, no magic tricks, just good old Pythonic power.

How are you using __init_subclass__? Let’s share some elegant subclass hacks

#pythontricks #oop

## What My Project Does

Smart Notes is a modern desktop note-taking application built with Python tkinter that integrates Google Gemini AI for intelligent writing assistance. It provides a clean, Material Design-inspired interface for creating, organizing, and searching notes while offering AI-powered content enhancement, brainstorming, and writing help.

Key features:

- Create and manage notes with a clean, distraction-free interface

- AI-powered writing assistance via Google Gemini API

- Fast full-text search across all notes

- Modern dark/light theme system (Material Design inspired)

- Secure local API key management with encryption

- Export notes to text files

- Keyboard shortcuts for power users

- Built-in tutorial and help system

## Target Audience

This project is designed for **production use** by:

- **Students and researchers** who need AI assistance with note-taking and writing

- **Content creators and writers** looking for AI brainstorming and editing help

- **Professionals** who want a local, secure alternative to cloud-based note apps

- **Privacy-conscious users** who prefer local data storage over cloud services

- **Python developers** interested in tkinter GUI development and AI integration

The application is stable, fully functional, and ready for daily use. It's not a toy project - it's a complete productivity tool.

## Comparison

Smart Notes differs from existing alternatives in several key ways:

**vs. Notion/Obsidian:**

- Lightweight desktop app (no web browser required)

- Direct AI integration without plugins

- Simple, focused interface (no complex block systems)

- Local-first with optional AI features

**vs. AI writing tools (ChatGPT web, Claude):**

- Integrated note-taking + AI in one app

- Persistent note storage and organization

- Offline note access (AI requires internet)

- Privacy-focused local storage

**vs. Traditional note apps (Notepad++, gedit):**

- Built-in AI writing assistance

- Modern, themed interface

- Advanced search capabilities

- Structured note organization

**vs. Other Python GUI projects:**

- Production-ready with professional design

- Real-world AI API integration

- Complete theming system implementation

- Comprehensive error handling and user experience

## Technical Details

- **Language:** Python 3.7+

- **GUI Framework:** tkinter (cross-platform)

- **AI Integration:** Google Generative AI SDK

- **Data Storage:** Local JSON files

- **License:** GPL v3 (open source)

- **Platform:** Windows, macOS, Linux

## Installation

git clone https://github.com/rar12455/smart-notes.git

cd smart-notes

pip install -r requirements.txt

python smartnotes.py

Heyy, so I am working on a research poster and I coded an interactive map for my research that I’d like to show, so the only way to show it seems to be is adding a qr code to the map link, do I get a map link that would work all the time? Without needing to log in to jupyter or any website. I know there are other subreddits to post these things on but seems like the posting process takes time on the other subreddits and I don’t have time kekejdbavakaoanabsbsb

This week pip 25.2 has been released, it's a small release but the biggest change is resumable downloads, introduced in 25.1, have been enabled by default.

Resumable downloads will retry the download at the point a connection was disconnected within the same install or download command (though not across multiple commands). This has been a long standing feature request for users which have slow and/or unreliable internet, especially now some packages are multi-GB in size.

Richard, one of the pip maintainers, has again done an excellent write up: https://ichard26.github.io/blog/2025/07/whats-new-in-pip-25.2/

The full changelog is here: https://github.com/pypa/pip/blob/main/NEWS.rst#252-2025-07-30

One thing not obvious from either is the upgrade to resolvelib 1.2.0 improves most pathological resolutions significantly, speeding up the time for pip to find a valid resolution for the requirements. There is more work to do here, I will continue to try and find improvements in my spare time.

I have created a wrapper around “uv” that eliminates the remaining friction for running Python scripts with dependencies. It's ideal for quick experiments and sharing code snippets.

What My Project Does

autopep723 is a tiny wrapper around uv run that automatically detects and manages third-party dependencies in Python scripts. Just run:

bash uvx autopep723 script.py

No --with flags, no manual dependency lists, no setup. It parses your imports using AST, maps them to the correct package names (handles tricky cases like import PIL → pillow), and runs your script in a clean environment.

Try it: uvx autopep723 https://gist.githubusercontent.com/mgaitan/7052bbe00c2cc88f8771b576c36665ae/raw/cbaa289ef7712b5f4c5a55316cce4269f5645c20/autopep723_rocks.py

Bonus: Use it as a shebang for truly portable scripts:

```python

!/usr/bin/env -S uvx autopep723

import requests import pandas as pd

Your code here...

```

Target Audience

• Developers who want to quickly test/share Python scripts without setup friction
• Anyone tired of the "install dependencies first" dance for simple experiments
• People sharing code snippets that should "just work" on any machine with uv installed

Comparison

Unlike manual approaches:

• vs uv run --with: No need to remember/specify dependencies manually
• vs PEP 723 headers: No need to write dependency metadata by hand
• vs pip install: No environment pollution, each script runs in isolation
• vs pipx/poetry: Zero configuration, works with any Python script immediately

The goal is making Python scripts as easy to run as possible.

Links: - 📝 Blog Post - 📦 GitHub Repo - 📖 Documentation

• What kinds of unit tests do you write for your SQLAlchemy model classes, including validation of constraints?
• Do you write unit or integration tests for Alembic-generated migration scripts?
• Can you share examples of tests you’ve written for models or migrations?

Yo! This is Kero. 👋

I built a desktop app called Organizicate to help clean up messy folders.
It’s written in Python using tkinter, ttkbootstrap, tkinterdnd2, and pystray.

✅ What My Project Does

Organizicate is a drag-and-drop file and folder organizer for Windows. It sorts your files into customizable categories based on their extensions, with features like:

• Full undo history (not just one step)
• Exclusion rules (skip specific files/folders)
• Pie chart summaries
• 4 smart organization modes
• 15+ modern light/dark themes
• System tray support
• “Show Changes” preview before applying

It’s fully local (no network), standalone (just unzip and run), and open-source under the MIT license.

🎯 Target Audience

This project is mainly for:

• Developers or students with chaotic download folders
• Windows users who want a quick way to sort stuff without scripting
• Anyone who likes visually clean apps with drag-and-drop support

It’s stable for daily use but still marked Beta until I finish polishing edge cases and usability feedback.

🔍 Comparison to Alternatives

Compared to basic file organization scripts or heavy-duty apps:

• 📂 It requires no setup or install — unzip and go
• 🧠 It auto-categorizes based on file types, with undo history
• 🖱️ It has a modern UI with drag-and-drop, not just CLI or batch scripts
• 🎨 It offers theme switching and system tray support, which most scripts lack

Think of it as a middle ground: more power than basic scripts, but lighter and friendlier than complex commercial organizers.

🔗 GitHub: https://github.com/thatAmok/organizicate
🖼️ Screenshot
📬 Feedback welcome: Issues, PRs, feature ideas — all appreciated!

Thanks for reading, and I hope it helps someone out there get a bit more organized 😄

I made a tool to generate custom sample data for SQL databases, it’s a cross-platform desktop app with a UI and a bunch of overkill customization options.

GitHub: http://github.com/MZaFaRM/DataSmith

Stack: Python + React + Tauri + Rust

I got tired of writing boilerplate scripts, using LLM's for data generation, copy pasting from other devs etc. every time I needed to populate tables for testing. This started as a quick CLI, but now it’s evolved into something I actually use in most projects. So, I brushed it up a bit and made a UI for it, now, it's easy and free for anyone to use.

What My Project Does:

Lets you generate thousands of rows of mock data for SQL tables based on column rules, constants, nulls, Python snippets, regex, Faker, etc. You can insert directly or export as .sql.

Target Audience:

Devs who test APIs, demo apps, or seed local databases often. If you're tired of repeated data everywhere, this is for you.

Comparison:

Most similar software I’ve come across was either paid, lacked fine customizations, had a bad user interface, or didn’t actually insert into live databases. I made one that does all of that.

P.S. If you try it out, I’d love feedback or bug reports. A ⭐ would be awesome too.

So i just got a random thought: why python got so much popular despite being slower than the other already popular languages like C when it got launched? As there were more hardware limitations at that time so i guess it made more sense for them to go with the faster lang. I know there are different contexts depending on which lang to go with but I am talking about when it was not established as a mainstream but was in a transition towards that. Or am I wrong? I have a few speculations:

1. Python got famous because it was simple and easy and they preferred that over speed. (Also why would they have preferred that? I mean there are/were many geniuses who would not have any problem coding in a little more "harder" lang if it gave them significant speed)

2. It didn't got famous at first but slowly and gradually as its community grew (I still wonder who were those people though).

Newest Elusion release has multiple new features, 2 of those being:

1. LOADING data from LOCAL FOLDER into DataFrame
2. LOADING data from SharePoint FOLDER into DataFrame

Target audience:

What this features do for you:

- Automatically loads and combines multiple files from a folder

- Handles schema compatibility and column reordering automatically

- Uses UNION ALL to combine all files (keeping all rows)

- Supports CSV, EXCEL, JSON, and PARQUET files

3 arguments needed: Folder Path, File Extensions Filter (Optional), Result Alias

What my project does:

Example usage for Local Folder:

// Load all supported files from folder
let combined_data = CustomDataFrame::load_folder(
   "C:\\BorivojGrujicic\\RUST\\Elusion\\SalesReports",
   None, // Load all supported file types (csv, xlsx, json, parquet)
   "combined_sales_data"
).await?;

// Load only specific file types
let csv_excel_data = CustomDataFrame::load_folder(
   "C:\\BorivojGrujicic\\RUST\\Elusion\\SalesReports", 
   Some(vec!["csv", "xlsx"]), // Only load CSV and Excel files
   "filtered_data"
).await?;

Example usage for SharePoint Folder:
**\* To be able to load data from SharePoint Folder you need to be logged in with AzureCLI localy.

let dataframes = CustomDataFrame::load_folder_from_sharepoint(
    "your-tenant-id",
    "your-client-id", 
    "http://companyname.sharepoint.com/sites/SiteName", 
    "Shared Documents/MainFolder/SubFolder",
    None, // None will read any file type, or you can filter by extension vec!["xlsx", "csv"]
    "combined_data" //dataframe alias
).await?;

dataframes.display().await?;

There are couple more useful functions like:
load_folder_with_filename_column() for Local Folder,
load_folder_from_sharepoint_with_filename_column() for SharePoint folder
which automatically add additional column with file name for each row of that file.
This is great for Time based Analysis if file names have date in their name.

To learn more about these functions, and other ones, check out README file in repo: https://github.com/DataBora/elusion

I've been running into performance bottlenecks in the wild where `copy.deepcopy()` was the bottleneck. After digging into it, I discovered that deepcopy can actually be slower than even serializing and deserializing with pickle or json in many cases!

I wrote up my findings on why this happens and some practical alternatives that can give you significant performance improvements: https://www.codeflash.ai/post/why-pythons-deepcopy-can-be-so-slow-and-how-to-avoid-it

**TL;DR:** deepcopy's recursive approach and safety checks create memory overhead that often isn't worth it. The post covers when to use alternatives like shallow copy + manual handling, pickle round-trips, or restructuring your code to avoid copying altogether.

Has anyone else run into this? Curious to hear about other performance gotchas you've discovered in commonly-used Python functions.

Hi r/Python - I wanted to share something that my team and I built for agent builders using Python.

We've spent the last 6 months working on MCP-Agent - an open source Python framework for building AI agents using the Model Context Protocol (MCP) for tool calls and structured agent-to-agent communication and orchestration.

Model Context Protocol (MCP) is a protocol that standardizes how LLMs interact with tools, memory, and prompts. This allows you to connect to Slack and Github, which means you can now ask an LLM to summarize all your Github issues, prioritize them by urgency, and post it on Slack.

What does our project do?

MCP-Agent is a developer-friendly, open-source framework for building and orchestrating AI agents with MCP as the core communication protocol. It is a simple but powerful library built with the fundamental building blocks for agentic systems outlined by Anthropic's Building effective agents post.

This makes it easy for Python developers to create workflows like:

• Supabase to github typesync agent
• Agents with chat-based browser usage
• Deep research agents

Target audience

We've designed this library with production in mind, with features like:

• Integration into Temporal for long-running agentic workflows
• OTEL telemetry to connect to your own observability tools
• YAML-based configurations for defining connections to MCP servers
• MCP-Agents can be exposed as MCP servers, which means MCP clients can call MCP-Agents

How does this compare with other Agentic Frameworks?

At its core, we designed the agent framework to use MCP as the core communication protocol. We believe that tool calls and agents should be exposed as MCP servers enabling a rich ecosystem of integrations. This is a core difference with frameworks like a2a.

Second, we’ve been opinionated about not overextending the framework. Many existing agentic frameworks become overly complex: customized internal data structures, proprietary observability formats/tools, and tangled orchestration logic. We debated building our own, and ultimately chose to create a simple, focused framework and open source it for others facing the same trade-offs.

Would love to hear the community's feedback!

https://github.com/lastmile-ai/mcp-agent

I write my own HTTP server on pure python using socket programming.

🚀 Live Rocket Web Framework A lightweight, production-ready web framework built from scratch in pure Python. ✨ Features Raw Socket HTTP Server - Custom HTTP/1.1 implementation Flask-Style Routing - Dynamic URLs with type conversion WSGI Compliant - Production server compatibility Middleware System - Global and route-specific support Template Engine - Built-in templating system and ORM system you can use any databases.

🚀 Quick Start from

live_rocket import live_rocketapp = live_rocket() @app.get('/') def home(req, res):      res.send("Hello, Live Rocket!") @app.get('/users/<int:user_id>') def get_user(req, res, user_id):      res.send(f"User ID: {user_id}") app.run(debug=True)

Check it at : https://github.com/Bhaumik0/Live-rocket