Unlock FastAPI's Performance with Async Python

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

Every time you write obj.attribute in Python, something runs that most developers have never heard of. Day 05 of 30 -- Descriptors and Properties Advanced Python + Real Projects Series When Django marks a field dirty on assignment, when SQLAlchemy tracks changes for save(), when Pydantic validates on every write -- they all use the same mechanism. The descriptor protocol. A descriptor is any object defining get, set, or delete. When it sits as a class attribute, Python routes all attribute access through it -- before the instance dict is even touched. Today's Topic covers: Why descriptors exist and what problem @property alone cannot solve The full descriptor protocol -- get, set, delete, set_name Data vs non-data descriptors and why the difference controls lookup priority The 3-level attribute lookup chain Python follows on every access Annotated syntax -- from @property to a fully reusable Validated field Real e-commerce scenario -- auto type check, range validation, and audit logging on every field write across 30 model classes with 3 lines of code How Django, SQLAlchemy, Pydantic, and dataclasses all use this internally 4 mistakes including the infinite recursion trap that kills production apps Key insight: When you write user.email in Django, that single line triggers a descriptor that queues the change for save(). No magic. Just the descriptor protocol. #Python #PythonProgramming #Django #SQLAlchemy #SoftwareEngineering #BackendDevelopment #100DaysOfCode #LearnPython #PythonDeveloper #TechContent #DataEngineering #BuildInPublic #TechIndia #CleanCode #LinkedInCreator #PythonTutorial

🐍 The developer just had to name it python 🐍 Respect ✊ *Guido van Rossum* He was Python’s “Benevolent Dictator For Life” (BDFL) until stepping down in 2018. Now Python’s run by a steering council It could have been given any other name but he just settled for python 🐍 😁😂😂😂😂😂😂😂😂😂😂 The chances of seriously listening to phython code will make you a star in programming, try it. This example uses SMTP (works with Gmail, Outlook, or most mail servers). import smtplib from email.mime.text import MIMEText from email.mime.multipart import MIMEMultipart from datetime import datetime # Email configuration SMTP_SERVER = "smtp.gmail.com" SMTP_PORT = 587 EMAIL_ADDRESS = "your_email@gmail.com" EMAIL_PASSWORD = "your_app_password" # Recipient TO_EMAIL = "recipient@example.com" def generate_report(): # Replace this with your real report logic today = datetime.now().strftime("%Y-%m-%d") report = f""" Daily Report - {today} - System Status: OK - Users Active: 120 - Errors Logged: 2 Regards, Automated System """ return report def send_email(): report = generate_report() msg = MIMEMultipart() msg["From"] = EMAIL_ADDRESS msg["To"] = TO_EMAIL msg["Subject"] = "Daily Automated Report" msg.attach(MIMEText(report, "plain")) try: server = smtplib.SMTP(SMTP_SERVER, SMTP_PORT) server.starttls() server.login(EMAIL_ADDRESS, EMAIL_PASSWORD) server.send_message(msg) server.quit() print("Email sent successfully!") except Exception as e: print("Error:", e) if __name__ == "__main__": send_email()

🚀 Restarting My Problem-Solving Journey (with a twist) I’ve already solved several problems on LeetCode using Java ☕ But now, I’ve decided to solve them again using Python 🐍 Why? Because I want to strengthen my fundamentals and become flexible with different technologies. 🧩 Today’s Problem: Score of a String 💡 Approach: Traverse the string Compare adjacent characters Add the absolute difference of their ASCII values 💻 Solution (Python): def scoreOfString(s): score = 0 for i in range(len(s) - 1): score += abs(ord(s[i]) - ord(s[i + 1])) return score 🔍 What I noticed: Python makes the code shorter and more readable Logic remains the same, but implementation differs Re-solving problems improves problem-solving depth 📌 Goal: Build strong problem-solving skills + master Python for Data Analytics #LeetCode #Python #Java #ProblemSolving #CodingJourney #DataAnalytics #Consistency

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

Python: @staticmethod vs @classmethod (Explained Simply) In Python classes, not all methods behave the same. There are 3 types of methods: 1) Instance Method: Works with object data. def show_name(self): • Uses self. • Accesses instance variables. 2) Class Method (@classmethod): Works with class-level data. @classmethod • Uses cls. • Can modify class variables. • Shared across all objects. 3) Static Method (@staticmethod): Independent utility function. @staticmethod • No self, no cls. • Doesn’t modify class or instance. • Used for helper logic. In this example: • show_name() → works on object. • change_company() → updates company for all employees. • greet() → simple helper function. Think of it like this: - Instance → works with object. - Class → works with class. - Static → works independently. Comment down, Which one do you use most in your code?

 🚀 microvec is a lightweight micro-vector database in pure Python. If you're building RAG pipelines, semantic search, or anything with embeddings and don't want to spin up a full vector DB service, this is for you.  What it does:  - Store vectors alongside document text and metadata  - Search by cosine, euclidean, or dot product similarity  - Filter results with any Python predicate before scoring  - Batch insert, update, and delete nodes  - Persist to disk safely (no pickle — JSON + numpy format)  What's new in v0.1.0:  - Complete rewrite from prototype to production-ready library  - Search results now return the actual document text, not just an index  - Full input validation with descriptive errors  - 107 tests, 98.5% coverage, mypy strict, ruff clean  Install: pip install microvec  No servers. No config. Just embeddings.  GitHub: https://lnkd.in/dnxWycy9

Python is not good at aggregations, offload it to databases. A common pattern in Django codebases - Fetch all orders. Loop through them in Python. Count items. Calculate totals. Build a summary. It works, but it's one of the most expensive things the ORM can do. A Python loop over 100,000 orders to calculate totals = loading 100,000 model instances into memory, iterating and compute. The database is better at this. It was designed for exactly this. annotate() and aggregate() are how Django handles these computations. 1. aggregate() - one value for the entire queryset aggregate() collapses the entire queryset into a single computed result. One query. One result. No Python loop. 2. annotate() — one value per row annotate() adds a computed column to each row in the queryset. Every order gets its item count attached. Still a single query. Takeaways - → Performance: Database computation is orders of magnitude faster than Python loops at scale → Clarity: aggregate() for summaries, annotate() for per-row enrichment → Memory: Neither loads unnecessary data into Python, computation stays in the database The ORM is not just a way to fetch data. It's a way to compute data at the source, before it ever reaches Python. I’m deep-diving into Django internals and performance. Do follow along and tell your experiences in comments. #Python #Django #DjangoInternals #SoftwareEngineering #BackendDevelopment

Here's a thing I'm noticing from porting TypeScript solutions into Python: The bugs cluster. They're not random. I keep hitting the same five or six friction points, and they're all places where TypeScript gave me a habit that Python doesn't want. The sum built-in shadowing thing has gotten me twice now. It's a free variable name in TypeScript. In Python, it's a loaded word, and the failure is silent. The interpreter doesn't warn you. Your code runs. It produces wrong answers. I also keep writing @dataclass with nobody. TypeScript lets you declare an empty class. Python wants at least a pass. This one's quick to fix, but I have to fix it every time because my fingers don't believe it yet. The interesting part, for me, is that I know every one of these rules. I've known them for a while. Knowing hasn't made them automatic. I still pause, correct, and move on. The pause is the whole problem. I'm curious whether this ever fully goes away for people who work in two languages daily, or if there's always a context-switch tax.

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