Django get_or_create Pattern Explained

Python Tracebacks in Claude Code? Hide the Framework Frames Created by jidonglab A Django traceback for a simple TemplateDoesNotExist error is 40+ lines. 35 of those lines are Django internals — django/template/loader.py, django/core/handlers/base.py, django/middleware/common.py. Your AI doesn't need to read Django's source to fix your missing template path. But it does, ever... link https://lnkd.in/ebnuWwJt pubDate Mon, 06 Apr 2026 03:27:55 +0000

Day 16 of my Python Full Stack journey. ✅ Today's topic: OOP — Object Oriented Programming. The biggest concept in Python so far. And the most important one for Django. Here's what clicked today: Everything in Python is an object. A class is just a blueprint for creating objects. Here's what I typed today: # Class = blueprint class Student: def __init__(self, name, marks): self.name = name self.marks = marks def result(self): if self.marks >= 50: return f"{self.name} — Pass ✅" return f"{self.name} — Fail ❌" # Object = actual instance built from blueprint s1 = Student("Punith", 88) s2 = Student("Rahul", 42) print(s1.result()) # Punith — Pass ✅ print(s2.result()) # Rahul — Fail ❌ Why this matters for Django: → Every Django Model is a class → Every Django View can be a class → Every Django Form is a class If you don't understand OOP — Django will feel like magic. If you do — Django will feel like logic. Today Django finally started making sense. 🤯 What concept made Django finally click for you? #PythonFullStack #Day16 #OOP #BuildingInPublic #100DaysOfCode #Bangalore

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

Day 12 of my Python Full Stack journey. ✅ Today's topic: Functions Deep Dive — the parts most beginners skip. *args and **kwargs. Looked confusing at first. Made complete sense after 45 minutes. Here's what I typed today: # Default arguments def greet(name, role="Developer"): print(f"Hey {name}, future {role}!") # *args — multiple positional arguments def add_all(*numbers): return sum(numbers) print(add_all(1, 2, 3, 4)) # 10 # **kwargs — multiple keyword arguments def show_info(**details): for key, value in details.items(): print(f"{key}: {value}") show_info(name="Punith", city="Bangalore", stack="Python") Why this matters for Django: → Django views use *args and **kwargs everywhere → Every class based view passes **kwargs automatically → Understanding this now saves hours of confusion later Pushed to GitHub immediately. Lesson learned. ✅ #PythonFullStack #Day12 #BuildingInPublic #100DaysOfCode #Bangalore

5 books. 6 database trips. That's your Django app bleeding performance. Most of the time we never notice the N+1 problem — until their app slows down under real data. Here's the fix explained as a story (swipe through) 👇 𝗦𝗹𝗶𝗱𝗲 𝟭 — You have 5 books. Each has an author. Simple. 𝗦𝗹𝗶𝗱𝗲 𝟮 — Without optimization: Django makes 6 separate DB trips. One per book. Painful. 𝗦𝗹𝗶𝗱𝗲 𝟯 — select_related() fixes it with a single JOIN. 1 trip. Everything together. 𝗦𝗹𝗶𝗱𝗲 𝟰 — But JOIN breaks with tags — Book 1 repeats 3 times. Messy. 𝗦𝗹𝗶𝗱𝗲 𝟱 — prefetch_related() makes 2 smart trips. Python glues them in memory. 𝗦𝗹𝗶𝗱𝗲 𝟲 — The rule: ONE thing → select_related. MANY things → prefetch_related. That's it. Two methods. One simple rule. #Django #Python #WebDevelopment #BackendDevelopment #SoftwareEngineering

I was debugging a Django service last week and hit a classic problem memory growing silently across requests, no obvious culprit. The usual suspects (tracemalloc, memory_profiler, objgraph) are great tools. But I wanted something I could drop on any function in 30 seconds and get a readable answer from. Also, honestly I wanted to understand what's happening at the GC and tracemalloc abstraction layer in Python. The best way I know to understand something is to build on top of it. So I built MemGuard over a weekend. What it does: Drop @memguard() on any function and after every call you get: Net memory retained (the actual leak signal) Peak vs net ratio — catches memory churn even when net looks clean Per-type gc object count delta tells you what is accumulating, not just how much Cross-call trend detection if net grows every call, it flags it Allocation hotspots via tracemalloc exact file and line Zero dependencies. Pure stdlib gc, tracemalloc, threading. @memguard() def process_batch(records): That's it. It also works as a context manager if you want to profile a block rather than a function. Biggest thing I learned building this: Python's gc and tracemalloc expose far more than most people use day to day. The object-reference graph alone tells a story that byte counts miss entirely. Repo: https://lnkd.in/gdjkHvfb Would love feedback from anyone who's dealt with Python memory issues in production. #Python #Django #SoftwareEngineering #OpenSource #BackendDevelopment #MemoryManagement

Day 20 of my Python Full Stack journey. ✅ Today I did something most learners skip. Revision. Before jumping into — Advanced Python + Django — I went back and revised everything from first 4 weeks. Here's what I revised today: → Variables, Data Types, f-strings → Conditionals — if, elif, else → Loops — for, while, range() → Functions — *args, **kwargs, default arguments → Lists, Dictionaries, Tuples, Sets → Nested Data Structures → File Handling — read, write, append → OOP — Classes, Methods, Inheritance Why revision matters: Moving fast feels productive. But building on a shaky foundation always breaks later. Today I made sure my foundation is solid. So when Django hits — nothing feels alien. One thing that surprised me during revision: How much more sense OOP makes now compared to Day 16. Same concept. Completely different level of understanding. That's what consistency does. 💪 Day 21 tomorrow — Month 2 officially begins. List comprehensions, Lambda, Map, Filter. Advanced Python starts now. 🚀 What's the one Python concept you wish you had revised before moving to Django? #PythonFullStack #Day21 #Revision #BuildingInPublic #100DaysOfCode #Bangalore

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

Optimizing Django Queries: How to Avoid N+1 Problems One of the quickest ways to slow down your Django backend is the classic N+1 query issue. While working on Inboxit, I had to be deliberate about this especially when dealing with relationships between models. The fix I use most often: prefetch_related() It’s perfect for optimizing reverse relationships (when you have a ForeignKey pointing to your model and you need to access related data). Instead of making one query per object (which explodes with more records), prefetch_related fetches all the related data in just two queries one for the main objects and one for the related ones. This small change keeps response times fast and your API scalable as usage grows. Have you run into N+1 issues in your Django projects? What’s your go-to optimization technique? #Django #DRF #Python #BackendDevelopment #QueryOptimization #TechNigeria #webdev