Ryx: Django ORM in Rust with Python API

Your unittest.mock is lying to you. Tests pass in CI, production breaks, and nobody knows why. The problem? Hand-written mocks drift from the real API silently. I've been contributing to the Microcks open-source ecosystem, and I want to share my latest work on Microcks Testcontainers https://lnkd.in/edzprW5k family for Python. Microcks Testcontainers takes a different approach: your OpenAPI spec becomes the mock. Load it into a Microcks container inside your test suite, and it: - Mocks your dependencies using spec-defined examples - Contract tests your implementation against the spec - Catches API drift automatically I also built a demo app with Flask showing the pattern end-to-end. Library: https://lnkd.in/eXyXwpnB Demo app (Flask): https://lnkd.in/eRhXfKeZ Full step-by-step guide: https://lnkd.in/eBvxUJy8 #Python #Testing #Microservices #API #OpenAPI

🚀 Day 17 – Python API Integration Today I explored the power of Django REST Framework and how it simplifies building RESTful APIs in Python. 🔹 Key takeaways: Understood how Django REST Framework extends Django to build APIs efficiently Created a Django project and app structure (countryapi, countries) Built a Model (Country) to represent data Learned how Serializers convert Django models into JSON Used ModelViewSet to handle CRUD operations automatically Configured DefaultRouter to generate API endpoints 🔹 Implemented API endpoints: GET → Retrieve countries POST → Create new country PUT / PATCH → Update data DELETE → Remove data 💡 What stood out: Django REST Framework reduces a lot of boilerplate by providing built-in tools for serialization, routing, and request handling — making API development faster and more structured. 📌 This is a big step forward in building production-ready backend systems. #Python #DataEngineering #Django #DjangoRESTFramework #APIs #BackendDevelopment #LearningJourney #selfLearning

Learn how to build a Model Context Protocol server in Python using FastMCP, expose custom tools to Claude, and connect it to Claude for Desktop via STDIO transport. Not with a plugin or a third-party integration - just a Python file and about 15 minutes. That is what MCP (Model Context Protocol) actually is: you write a function, decorate it with @mcp.tool(), and Claude can call it directly from chat. The thing that genuinely surprised me when building this: you never write a JSON schema for the tool. FastMCP reads your type hints and docstring at startup and generates the schema automatically. That docstring is literally what Claude reads when it decides whether and how to call your function - so you write it like API documentation, not a code comment. That distinction matters more than it sounds. The full walkthrough is on my blog - 7 steps, free National Weather Service API, no API key needed. You finish with two working tools (get_alerts and get_forecast) registered in Claude for Desktop and callable from chat with real live data. https://lnkd.in/ee-EpVht

PySpector v0.1.8 is out🚀 Me and the PySpector Core Team worked really hard to deploy this version, so here's what changed: - A new vulnerability leading to arbitrary code execution via plugin bypass was patched (and its #GHSA was published) - Docs were updated and improved🫡 - We fixed a bug preventing the generation of html reports, as well as 2 other bugs preventing the --wizard and -- supply-chain flag from working properly - We expanded error messages during #AST file parsing and added a new #CLI flag to enable Python SyntaxWarnings during code scanning - And last we (finally) expanded support for Python up to the latest #Python3.14 (while before v.0.1.8, Python support stopped at #Python3.12) Thanks to all the #contributors and the awesome SecurityCert community who made this possible🫶 Repo: https://lnkd.in/d7CppftJ

Your Django API is not slow because of your database. It's slow because of serialization. A 17-field serializer on 1,000 records = 17,000 Python calls. Just to produce JSON. We hit this in a rental platform in Stockholm. 80ms → 3 seconds at 2,000 users. So we built ClaraX — Rust serialization for Django. One line. No rewrites. No Rust knowledge. Results: → 475ms → 14ms (33x) → 506ms → 10ms (50x) pip install clarax-django python manage.py clarax_doctor https://lnkd.in/dgmZgnK5

Do you know what Django, SQLAlchemy, and Pydantic all have in common? They are all built on metaclasses. Day 04 of 30 -- Metaclasses and Class Creation Advanced Python + Real Projects Series When you write class Order(Table): in Django, something runs before a single instance is created. The metaclass intercepts the class definition itself, reads your field declarations, and builds the SQL schema automatically. That is not magic. That is type. Today's topic covers: Why classes are objects and what that actually means The 3-level hierarchy -- type, class, instance The 5-step class creation lifecycle Python runs for every class keyword 4 approaches -- full metaclass, init_subclass, type(), class_getitem Full annotated syntax -- building a field-validation metaclass from scratch Real mini ORM -- auto-generate CREATE TABLE SQL from class definitions How Django, SQLAlchemy, Pydantic, abc, and enum all use this internally 4 mistakes including the metaclass conflict that breaks multiple inheritance Key insight: You do not need to write metaclasses often. But you need to understand them to read any serious Python framework. #Python #PythonProgramming #Django #SQLAlchemy #SoftwareEngineering #BackendDevelopment #100DaysOfCode #LearnPython #PythonDeveloper #TechContent #DataEngineering #BuildInPublic #TechIndia #CleanCode #LinkedInCreator #PythonTutorial

We recently received requests from clients around Python, Machine Learning, and Flask. Before diving into the more complex topics, we decided to start with a solid foundation: building a simple CRUD REST API using Flask and SQLite. No ORMs. No extra dependencies. Just Flask, Python's built-in sqlite3, and Pytest. The goal is straightforward: understand how a REST API actually works from the ground up, before adding layers of abstraction on top of it. It is the kind of foundation that makes everything else easier to learn and easier to debug. In this tutorial, we cover: → Structuring a Flask project with the application factory pattern → Managing database connections per request using Flask's g object → Building five CRUD endpoints with proper validation and error handling → Writing a complete Pytest suite with isolated test databases This is the first article in what will become a series. JWT authentication is coming up next. Read the full tutorial here: https://lnkd.in/g_DwkMDk

Just shipped stup 🚀 A python package that scaffolds production-ready Python projects in seconds. 🛠️ Every time I started a new project, I was doing the same thing: init uv, pin Python, create venv, wire up requirements.txt, set up folders. 10 minutes of setup before writing a single line of actual code. ⏳ stup kills that loop. One command, full scaffold⚡ → `stup django` : Django + DRF + Celery + Redis + PostgreSQL, ready to go → `stup lang-agent` : LangGraph agent with tools, memory, Ollama config → `stup react-fastapi` : Full-stack with Docker Compose and CORS pre-wired → `stup ml` : MLflow + PyTorch + scikit-learn experiment structure → `stup cli` : PyPI-ready package with Typer + Rich, entry_points set All templates build on top of `stup uv` which handles uv init, Python pinning, and venv in one shot. Install once: `pip install stup` source code: https://lnkd.in/duGUCXVH

Released on March 16, 2014, Python 3.4 arrived with zero new syntax features. None. If you were hoping for a new operator or a shiny keyword, you’d have been disappointed. What you got instead was something more durable: a standard library that finally felt like it was built for the modern web. https://lnkd.in/ddygQziM