<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1r3ofpf/help_i_dont_understanding_any_of_the_db/"> <img src="https://preview.redd.it/qcg2almoe9jg1.png?width=140&amp;height=113&amp;auto=webp&amp;s=48c8a3692f06263d626d353336463cf3f24294fe" alt="Help, i dont understanding any of the db connections variables, like db_dependency, engine or sessionlocal and base" title="Help, i dont understanding any of the db connections variables, like db_dependency, engine or sessionlocal and base" /> </a> </td><td> <div class="md">i was following a tutorial and he started to connect the db part to the endpoints of the api, and the moment he did this, alot of variables were introduced without being much explained, what does each part of those do, why we need all this for? also why did we do the try, yield and finally instead of ust return db? execuse my idnorance i am still new to this </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Beyond_Birthday_13"> /u/Beyond_Birthday_13 </a> <a href="https://www.reddit.com/gallery/1r3ofpf">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1r3ofpf/help_i_dont_understanding_any_of_the_db/">[comments]</a> </td></tr></table>

i was following a tutorial and he started to connect the db part to the endpoints of the api, and the moment he did this, alot of variables were introduced without being much explained, what does each part of those do, why we need all this for?
 also why did we do the try, yield and finally instead of ust return db?
 execuse my idnorance i am still new to this
    submitted by    /u/Beyond_Birthday_13  
 [link]   [comments]

Help, i dont understanding any of the db connections variables, like db_dependency, engine or sessionlocal and base

<div class="md">I know many people using fast-api use tortoise as orm, to minimise boilerplate code and to have more django-like experience. For many years people using tortoise had one big limitation - migrations support in tortoise was lacking, which pushed users to use Alembic together with SQLAlchemy for full-fledged migrations support. Tortoise did have migrations support via the Aerich library, but it came with a number of limitations: you had to connect to the database to generate migrations, migrations were written in raw SQL, and the overall coupling between the two libraries was somewhat fragile - which didn’t feel like a robust, reliable system. The new release includes a lot of additions and fixes, but I’d highlight two that are most important to me personally: <ul> <li>Built-in migrations, with automatic change detection in offline mode, and support for data migrations via RunPython and RunSQL.</li> <li>Convenient support for custom SQL queries using PyPika (the query builder that underpins Tortoise) and execute_pypika, including returning typed objects as results.</li> </ul> Thanks to this combination of new features, Tortoise ORM can be useful even if you don’t want to use it as an ORM: it offers an integrated migrations system (in my view, much more convenient and intuitive than Alembic) and a query builder, with minimal additional dependencies and requirements for your architecture. You can see example project for fast-api with tortoise and migrations at {github}/tortoise/tortoise-orm/tree/develop/examples/fastapi (sorry for not linking directly, afraid of reddit auto-ban) Try it out yourself, create issues, contribute through PRs </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/pehibah"> /u/pehibah </a> <a href="https://www.reddit.com/r/FastAPI/comments/1r00kl2/tortoise_orm_10_release_with_migrations_support/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1r00kl2/tortoise_orm_10_release_with_migrations_support/">[comments]</a>

I know many people using fast-api use tortoise as orm, to minimise boilerplate code and to have more django-like experience.
 For many years people using tortoise had one big limitation - migrations support in tortoise was lacking, which pushed users to use Alembic together with SQLAlchemy for full-fledged migrations support.
 Tortoise did have migrations support via the Aerich library, but it came with a number of limitations: you had to connect to the database to generate migrations, migrations were written in raw SQL, and the overall coupling between the two libraries was somewhat fragile - which didn’t feel like a robust, reliable system.
 The new release includes a lot of additions and fixes, but I’d highlight two that are most important to me personally:
  
Built-in migrations, with automatic change detection in offline mode, and support for data migrations via RunPython and RunSQL.
 Convenient support for custom SQL queries using PyPika (the query builder that underpins Tortoise) and execute_pypika, including returning typed objects as results.
  
Thanks to this combination of new features, Tortoise ORM can be useful even if you don’t want to use it as an ORM: it offers an integrated migrations system (in my view, much more convenient and intuitive than Alembic) and a query builder, with minimal additional dependencies and requirements for your architecture.
 You can see example project for fast-api with tortoise and migrations at
 {github}/tortoise/tortoise-orm/tree/develop/examples/fastapi (sorry for not linking directly, afraid of reddit auto-ban)
 Try it out yourself, create issues, contribute through PRs
    submitted by    /u/pehibah  
 [link]   [comments]

Tortoise ORM 1.0 release with migrations support

<div class="md">Hey folks I’ve been using FastAPI for ~5 years now and I probably spend an unhealthy amount of time staring at Swagger every single day. I actually like the default theme. It’s clean and familiar. But after a few hours… especially at night… it starts feeling like I’m getting flashbanged by my own API docs :D So I thought, instead of replacing Swagger with a completely different theme, why not just add a proper Dark / Light toggle? I’ve seen dark-mode versions before ( <a href="/u/BlueFriends">u/BlueFriends</a> and <a href="/u/Fit_Tell_8592">u/Fit_Tell_8592</a> did some cool stuff), but I wanted something that keeps the original Swagger vibe and just enhances it a bit. My goal was to: • Keep the original Swagger feel • Add a smooth Dark / Light toggle • Not break FastAPI defaults • Implement smth that is easy to plug into existing projects(actually 1 line) You can enable it with literally one line of code. Your eyesight is worth more than 1 line of code :D So I built this: Repo: <a href="https://github.com/akutayural/fastapi-swagger-ui-theme">https://github.com/akutayural/fastapi-swagger-ui-theme</a> Pypi: <a href="https://pypi.org/project/fastapi-swagger-ui-theme/">https://pypi.org/project/fastapi-swagger-ui-theme/</a> Contributions, ideas, improvements, or even nitpicks are very welcome. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/SpecialistCamera5601"> /u/SpecialistCamera5601 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1r33cxm/i_added_a_dark_light_mode_toggle_to_fastapi/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1r33cxm/i_added_a_dark_light_mode_toggle_to_fastapi/">[comments]</a>

Hey folks 
 I’ve been using FastAPI for ~5 years now and I probably spend an unhealthy amount of time staring at Swagger every single day.
 I actually like the default theme. It’s clean and familiar. But after a few hours… especially at night… it starts feeling like I’m getting flashbanged by my own API docs :D 
 So I thought, instead of replacing Swagger with a completely different theme, why not just add a proper Dark / Light toggle?
 I’ve seen dark-mode versions before ( u/BlueFriends and u/Fit_Tell_8592 did some cool stuff), but I wanted something that keeps the original Swagger vibe and just enhances it a bit.
 My goal was to:
 • Keep the original Swagger feel
 • Add a smooth Dark / Light toggle
 • Not break FastAPI defaults
 • Implement smth that is easy to plug into existing projects(actually 1 line)
 You can enable it with literally one line of code. Your eyesight is worth more than 1 line of code :D 
 So I built this:
 Repo:
 https://github.com/akutayural/fastapi-swagger-ui-theme
 Pypi:
 https://pypi.org/project/fastapi-swagger-ui-theme/
 Contributions, ideas, improvements, or even nitpicks are very welcome.
    submitted by    /u/SpecialistCamera5601  
 [link]   [comments]

I added a Dark / Light mode toggle to FastAPI Swagger UI

<div class="md">Hi All, I spent the weekend tweaking a strict .cursorrules file for FastAPI + Pydantic v2 projects because I got tired of fixing: <ul> <li><code>class Config:</code> instead of <code>model_config = ConfigDict(...)</code></li> <li>Sync DB calls inside async routes</li> <li>Missing type hints</li> </ul> It forces the AI to use: <ul> <li>Python 3.11+ syntax (<code>|</code> types)</li> <li>Async SQLAlchemy 2.0 patterns</li> <li>Google-style docstrings</li> </ul> If anyone wants the config file, let me know in the comments and I&#39;ll DM it / post the link (it&#39;s free).&quot; </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/zupiterss"> /u/zupiterss </a> <a href="https://www.reddit.com/r/FastAPI/comments/1r40lcf/finally_got_cursor_ai_to_stop_writing_deprecated/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1r40lcf/finally_got_cursor_ai_to_stop_writing_deprecated/">[comments]</a>

Hi All,
 I spent the weekend tweaking a strict 
 .cursorrules file for FastAPI + Pydantic v2 projects because I got tired of fixing:
  
class Config: instead of model_config = ConfigDict(...)
 Sync DB calls inside async routes
 Missing type hints
  
It forces the AI to use:
  
Python 3.11+ syntax (| types)
 Async SQLAlchemy 2.0 patterns
 Google-style docstrings
  
If anyone wants the config file, let me know in the comments and I'll DM it / post the link (it's free)."
    submitted by    /u/zupiterss  
 [link]   [comments]

Finally got Cursor AI to stop writing deprecated Pydantic v1 code (My strict .cursorrules config)

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1r3su01/built_a_lightweight_actuatorstyle_extension_for/"> <img src="https://external-preview.redd.it/FjOFbv64aVKnr7NEMFedYi2VMtR2xC9T9vZs0b7ix3U.png?width=640&amp;crop=smart&amp;auto=webp&amp;s=c7cffa487cfa1248b78190fd39641fe191cffa77" alt="Built a lightweight Actuator-style extension for FastAPI – looking for feedback" title="Built a lightweight Actuator-style extension for FastAPI – looking for feedback" /> </a> </td><td> <div class="md">Hi everyone, While building APIs with FastAPI, one thing I kept missing from my earlier experience with Spring Boot was Actuator. I liked being able to quickly check: is the app alive is it ready to serve traffic what version is deployed runtime metrics which endpoints exist So I started building a small, lightweight actuator-style extension for FastAPI. Current features /actuator/health/live /actuator/health/ready /actuator/info /actuator/metrics /actuator/platform /actuator/mappings It also supports pluggable readiness checks, so applications can register something like a DB check and readiness will depend on it. The goal is to keep it simple, fast, and easy to plug into any service without bringing heavy dependencies. I haven’t published it to PyPI yet — it’s currently just on GitHub. I would really appreciate feedback on: API design missing essentials naming things that would make this useful in real projects If you’ve worked on production systems, I’d love to know what you typically expect from an actuator endpoint. Thanks 🙏 </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/DSpy01"> /u/DSpy01 </a> <a href="https://github.com/Abhijit0303/fastapi-actuator">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1r3su01/built_a_lightweight_actuatorstyle_extension_for/">[comments]</a> </td></tr></table>

Hi everyone, While building APIs with FastAPI, one thing I kept missing from my earlier experience with Spring Boot was Actuator.
 I liked being able to quickly check: is the app alive is it ready to serve traffic what version is deployed runtime metrics which endpoints exist
 So I started building a small, lightweight actuator-style extension for FastAPI.
 Current features /actuator/health/live /actuator/health/ready /actuator/info /actuator/metrics /actuator/platform /actuator/mappings
 It also supports pluggable readiness checks, so applications can register something like a DB check and readiness will depend on it. The goal is to keep it simple, fast, and easy to plug into any service without bringing heavy dependencies. I haven’t published it to PyPI yet — it’s currently just on GitHub.
 I would really appreciate feedback on: API design missing essentials naming things that would make this useful in real projects
 If you’ve worked on production systems, I’d love to know what you typically expect from an actuator endpoint. Thanks 🙏
    submitted by    /u/DSpy01  
 [link]   [comments]

Built a lightweight Actuator-style extension for FastAPI – looking for feedback

<div class="md">I want to be able to send both a json file and a json formatted string via a submission on the ui. If it&#39;s getting sent via a requests script I know hwo that can be done from the UI. I have tried looking around but from what I&#39;ve seen, having <code>FileUpload</code> and a <code>Body</code> parameter on the same method isn&#39;t compatible. I was able to get working an input line, but only a single line input for the json string. When I tried looking in to my case I see something about a limitation in how FastAPI interacts with http. I&#39;m just a bit stuck on ginding a solution or workaround for the situation </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/aconfused_lemon"> /u/aconfused_lemon </a> <a href="https://www.reddit.com/r/FastAPI/comments/1r0p3xz/sending_a_file_and_json_string_body_via_the/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1r0p3xz/sending_a_file_and_json_string_body_via_the/">[comments]</a>

I want to be able to send both a json file and a json formatted string via a submission on the ui. If it's getting sent via a requests script I know hwo that can be done from the UI. 
 I have tried looking around but from what I've seen, having FileUpload and a Body parameter on the same method isn't compatible. I was able to get working an input line, but only a single line input for the json string. When I tried looking in to my case I see something about a limitation in how FastAPI interacts with http.
 I'm just a bit stuck on ginding a solution or workaround for the situation
    submitted by    /u/aconfused_lemon  
 [link]   [comments]

Sending a file and json string body via the Swagger ui page?

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1r4iiw4/persistent_hybrid_rag_adding_postgresql_faiss/"> <img src="https://external-preview.redd.it/feNel6zrGZ_gSL2Fznnyf7w6qoIvNNIuuAsChu02sH8.jpeg?width=320&amp;crop=smart&amp;auto=webp&amp;s=6fe741ab81376cc7c6a7a1a36f06b201926a389a" alt="Persistent Hybrid RAG: Adding PostgreSQL &amp; FAISS Storage (Part 2)" title="Persistent Hybrid RAG: Adding PostgreSQL &amp; FAISS Storage (Part 2)" /> </a> </td><td> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Worldly_Mammoth_7868"> /u/Worldly_Mammoth_7868 </a> <a href="https://youtube.com/watch?v=VJW_vCFeoBc&amp;si=QfJjubwL15ju2gm2">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1r4iiw4/persistent_hybrid_rag_adding_postgresql_faiss/">[comments]</a> </td></tr></table>

submitted by    /u/Worldly_Mammoth_7868  
 [link]   [comments]

Persistent Hybrid RAG: Adding PostgreSQL & FAISS Storage (Part 2)

&#32; submitted by &#32; <a href="https://www.reddit.com/user/MoodyArtist-28"> /u/MoodyArtist-28 </a> <a href="/r/Backend/comments/1r1vb3x/online_contest_platform_simulation_load_testing/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1r1wtuz/online_contest_platform_simulation_load_testing/">[comments]</a>

submitted by    /u/MoodyArtist-28  
 [link]   [comments]

online contest platform - simulation & load testing

<div class="md">I was searching for a SaaS template for FastAPI and there have been a few posted here, and I am looking at each of them, but my search outside of Reddit led me to <a href="https://www.fast-saas.com/">https://www.fast-saas.com/</a>. - has anyone here used it? If so, any good or bad feedback would be appreciated. I emailed them earlier today but I have not gotten a response. Could be that it&#39;s Friday and maybe they are already on their weekend. - does anyone have a production site built with fast-saas that they would be willing to post a link to so I can evaluate it in the wild? Thanks in advance </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Natural-Ad-9678"> /u/Natural-Ad-9678 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1r42j1c/does_anyone_have_realworld_experience_with/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1r42j1c/does_anyone_have_realworld_experience_with/">[comments]</a>

I was searching for a SaaS template for FastAPI and there have been a few posted here, and I am looking at each of them, but my search outside of Reddit led me to https://www.fast-saas.com/.
 - has anyone here used it? If so, any good or bad feedback would be appreciated. I emailed them earlier today but I have not gotten a response. Could be that it's Friday and maybe they are already on their weekend.
 - does anyone have a production site built with fast-saas that they would be willing to post a link to so I can evaluate it in the wild?
 Thanks in advance
    submitted by    /u/Natural-Ad-9678  
 [link]   [comments]

Does anyone have real-world experience with fast-saas

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1r2pdb1/built_a_hybrid_rag_api_with_fastapi_ollama_sparse/"> <img src="https://external-preview.redd.it/w8vjY9Qu_YvRw76dI_06g2SUQxswsi_3POGaFDFWgOA.jpeg?width=320&amp;crop=smart&amp;auto=webp&amp;s=5d502a2bcf3f091e820511b28f07d781ad4137b4" alt="Built a Hybrid RAG API with FastAPI &amp; Ollama – Sparse + Dense retrieval in action." title="Built a Hybrid RAG API with FastAPI &amp; Ollama – Sparse + Dense retrieval in action." /> </a> </td><td> <div class="md">Stop building basic RAG apps that fail in production. Learn how to combine BM25 Keyword Search with FAISS Vector Search and layer on a Cross-Encoder Reranker for the most accurate AI answers. The Summary: In this tutorial, we dive deep into building a professional Retrieval-Augmented Generation (RAG) system using FastAPI and Ollama. We don&#39;t just stop at vector search; we implement Hybrid Search and Reranking to ensure your LLM gets the absolute best context every single time. Key Features Covered: 🚀 FastAPI Integration: Build a real-time API for document ingestion. 🔍 Hybrid Search: Combining BM25 (Sparse) and FAISS (Dense) retrieval. 🎯 Reranking: Using Cross-Encoders to re-score candidates for precision. 🧠 Local LLM: Running Phi-3 via Ollama for private, local generation. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Worldly_Mammoth_7868"> /u/Worldly_Mammoth_7868 </a> <a href="https://youtu.be/tzNtiEj9Kg8?si=SGvAhncVq5WIO3A2">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1r2pdb1/built_a_hybrid_rag_api_with_fastapi_ollama_sparse/">[comments]</a> </td></tr></table>

Stop building basic RAG apps that fail in production. Learn how to combine BM25 Keyword Search with FAISS Vector Search and layer on a Cross-Encoder Reranker for the most accurate AI answers. 
 The Summary: 
 In this tutorial, we dive deep into building a professional Retrieval-Augmented Generation (RAG) system using FastAPI and Ollama. We don't just stop at vector search; we implement Hybrid Search and Reranking to ensure your LLM gets the absolute best context every single time. 
 Key Features Covered: 
 🚀 FastAPI Integration: Build a real-time API for document ingestion. 
 🔍 Hybrid Search: Combining BM25 (Sparse) and FAISS (Dense) retrieval. 
 🎯 Reranking: Using Cross-Encoders to re-score candidates for precision. 
 🧠 Local LLM: Running Phi-3 via Ollama for private, local generation.
    submitted by    /u/Worldly_Mammoth_7868  
 [link]   [comments]

Built a Hybrid RAG API with FastAPI & Ollama – Sparse + Dense retrieval in action.

<div class="md">Hey all. I&#39;ve been building <a href="https://github.com/definableai/definable.ai">Definable</a> - a Python framework for AI agents. I got frustrated with existing options being either too bloated or too toy-like, so I built what I actually wanted to use in production. Here&#39;s what it looks like: ```python from definable.agents import Agent from definable.models.openai import OpenAIChat from definable.tools.decorator import tool from definable.interfaces.telegram import TelegramInterface, TelegramConfig @tool def search_docs(query: str) -&gt; str: &quot;&quot;&quot;Search internal documentation.&quot;&quot;&quot; return db.search(query) agent = Agent( model=OpenAIChat(id=&quot;gpt-5.2&quot;), tools=[search_docs], instructions=&quot;You are a docs assistant.&quot;, ) <h1>Use it directly</h1> response = agent.run(&quot;Steps for configuring auth?&quot;) <h1>Or deploy it — HTTP API + Telegram bot in one line</h1> agent.add_interface(TelegramInterface( config=TelegramConfig(bot_token=os.environ[&quot;TELEGRAM_BOT_TOKEN&quot;]), )) agent.serve(port=8000) ``` <h2>What My Project Does</h2> Python framework for AI agents with built-in cognitive memory, run replay, file parsing (14+ formats), streaming, HITL workflows, and one-line deployment to HTTP + Telegram/Discord/Signal. Async-first, fully typed, non-fatal error handling by design. <h2>Target Audience</h2> Developers building production AI agents who&#39;ve outgrown raw API calls but don&#39;t want LangChain-level complexity. v0.2.6, running in production. <h2>Comparison</h2> <ul> <li>vs LangChain - No chain/runnable abstraction. Normal Python. Memory is multi-tier with distillation, not just a chat buffer. Deployment is built-in, not a separate project.</li> <li>vs CrewAI/AutoGen - Those focus on multi-agent orchestration. Definable focuses on making a single agent production-ready: memory, replay, file parsing, streaming, HITL.</li> <li>vs raw OpenAI SDK - Adds tool management, RAG, cognitive memory, tracing, middleware, deployment, and file parsing out of the box.</li> </ul> <code>pip install definable</code> Would love feedback. Still early but it&#39;s been running in production for a few weeks now. <a href="https://github.com/definableai/definable.ai">GitHub</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/anandesh-sharma"> /u/anandesh-sharma </a> <a href="https://www.reddit.com/r/FastAPI/comments/1r4k4qa/i_built_an_python_ai_agent_framework_that_doesnt/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1r4k4qa/i_built_an_python_ai_agent_framework_that_doesnt/">[comments]</a>

Hey all. I've been building Definable - a Python framework for AI agents. I got frustrated with existing options being either too bloated or too toy-like, so I built what I actually wanted to use in production.
 Here's what it looks like:
 ```python from definable.agents import Agent from definable.models.openai import OpenAIChat from definable.tools.decorator import tool from definable.interfaces.telegram import TelegramInterface, TelegramConfig
 @tool def search_docs(query: str) -> str: """Search internal documentation.""" return db.search(query)
 agent = Agent( model=OpenAIChat(id="gpt-5.2"), tools=[search_docs], instructions="You are a docs assistant.", )
 Use it directly
 response = agent.run("Steps for configuring auth?")
 Or deploy it — HTTP API + Telegram bot in one line
 agent.add_interface(TelegramInterface( config=TelegramConfig(bot_token=os.environ["TELEGRAM_BOT_TOKEN"]), )) agent.serve(port=8000) ```
 What My Project Does
 Python framework for AI agents with built-in cognitive memory, run replay, file parsing (14+ formats), streaming, HITL workflows, and one-line deployment to HTTP + Telegram/Discord/Signal. Async-first, fully typed, non-fatal error handling by design.
 Target Audience
 Developers building production AI agents who've outgrown raw API calls but don't want LangChain-level complexity. v0.2.6, running in production.
 Comparison
  
vs LangChain - No chain/runnable abstraction. Normal Python. Memory is multi-tier with distillation, not just a chat buffer. Deployment is built-in, not a separate project.
 vs CrewAI/AutoGen - Those focus on multi-agent orchestration. Definable focuses on making a single agent production-ready: memory, replay, file parsing, streaming, HITL.
 vs raw OpenAI SDK - Adds tool management, RAG, cognitive memory, tracing, middleware, deployment, and file parsing out of the box.
  
pip install definable
 Would love feedback. Still early but it's been running in production for a few weeks now.
 GitHub
    submitted by    /u/anandesh-sharma  
 [link]   [comments]

I built an python AI agent framework that doesn't make me want to mass-delete my venv

<div class="md">Greetings Django folks, I teach at UBC, but I also occasionally create instructional videos on YouTube. I created this guide for setting up a new Django project. Please let me know what you think. If you have ideas for other videos, that&#39;d be appreciated as well. thanks!! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/LorenzoDePolanco"> /u/LorenzoDePolanco </a> <a href="https://youtu.be/a6C1iuQ2Iac">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1r1xbkd/django_setup_howto_guide_for_2026_youtube/">[comments]</a>

Greetings Django folks, I teach at UBC, but I also occasionally create instructional videos on YouTube. I created this guide for setting up a new Django project. Please let me know what you think. If you have ideas for other videos, that'd be appreciated as well. thanks!!
    submitted by    /u/LorenzoDePolanco  
 [link]   [comments]

Django setup how-to guide for 2026 - YouTube

<div class="md">I have just a small django site up and running just so I could learn how to do an end to end setup/play with heroku deployments. Whats the best practice for handling the admin login console? I had used some django honeypot library to route the admin login page to some fake page that automatically email me when someone tries it, it seems like someone has been aggressively trying to login to it from the same IP address over and over again trying obviously things like user “admin”, “jqadmin”, “12345”. Doesn’t seem like they know it’s a fake login, what’s the best practice here for protecting that page? I thought about restricting the IP but do I even bother, wouldn’t they just start using a vpn making it kinda moot? Thanks in advance for any insights! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Zealousideal-Arm4994"> /u/Zealousideal-Arm4994 </a> <a href="https://www.reddit.com/r/djangolearning/comments/1r2fnk6/django_block_ip_address/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1r2fnk6/django_block_ip_address/">[comments]</a>

I have just a small django site up and running just so I could learn how to do an end to end setup/play with heroku deployments. Whats the best practice for handling the admin login console? I had used some django honeypot library to route the admin login page to some fake page that automatically email me when someone tries it, it seems like someone has been aggressively trying to login to it from the same IP address over and over again trying obviously things like user “admin”, “jqadmin”, “12345”. Doesn’t seem like they know it’s a fake login, what’s the best practice here for protecting that page? I thought about restricting the IP but do I even bother, wouldn’t they just start using a vpn making it kinda moot? Thanks in advance for any insights! 
    submitted by    /u/Zealousideal-Arm4994  
 [link]   [comments]

Django Block IP Address

&#32; submitted by &#32; <a href="https://www.reddit.com/user/jadd_logs"> /u/jadd_logs </a> <a href="/r/learnprogramming/comments/1r4elw1/need_help_with_standardizingsimplifying_logic/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1r4em6u/need_help_with_standardizingsimplifying_logic/">[comments]</a>

submitted by    /u/jadd_logs  
 [link]   [comments]

Need Help with Standardizing/Simplifying Logic Placement in DRF Projects.

&#32; submitted by &#32; <a href="https://www.reddit.com/user/jadd_logs"> /u/jadd_logs </a> <a href="/r/learnprogramming/comments/1r57fuc/had_an_epiphany_what_does_it_take_to_reach_50lpa/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1r57glg/had_an_epiphany_what_does_it_take_to_reach_50lpa/">[comments]</a>

Had an epiphany && What does it take to reach 50LPA?

&#32; submitted by &#32; <a href="https://www.reddit.com/user/Lokrea"> /u/Lokrea </a> <a href="https://www.bitecode.dev/p/beginners-should-use-django-not-flask">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r1uyap/beginners_should_use_django_not_flask/">[comments]</a>

submitted by    /u/Lokrea  
 [link]   [comments]

Beginners should use Django, not Flask

<div class="md">I’m focusing on React (frontend) and Django + DRF (backend), with PostgreSQL and AWS for deployment. I’m also planning to go deeper into backend fundamentals — things like Docker, CI/CD basics, caching (Redis), system design, and improving API design (auth, permissions, performance, etc.). I keep seeing a lot more noise around MERN/Node stacks lately, so I’m wondering — is this stack still competitive in the current job market? Are companies actively hiring for React + Django developers? And how does it look long-term compared to Node-based stacks? Would love honest opinions from people already working in industry. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/alokbind"> /u/alokbind </a> <a href="https://www.reddit.com/r/django/comments/1r4nkut/is_react_djangodrf_still_a_solid_stack_in_ai_era/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r4nkut/is_react_djangodrf_still_a_solid_stack_in_ai_era/">[comments]</a>

I’m focusing on React (frontend) and Django + DRF (backend), with PostgreSQL and AWS for deployment.
 I’m also planning to go deeper into backend fundamentals — things like Docker, CI/CD basics, caching (Redis), system design, and improving API design (auth, permissions, performance, etc.).
 I keep seeing a lot more noise around MERN/Node stacks lately, so I’m wondering — is this stack still competitive in the current job market?
 Are companies actively hiring for React + Django developers? And how does it look long-term compared to Node-based stacks?
 Would love honest opinions from people already working in industry.
    submitted by    /u/alokbind  
 [link]   [comments]

Is React + Django/DRF still a solid stack in AI era of 2026?

<div class="md">Hey team, I’ve just released dj-urls-panel It’s another panel in my series of django admin based tooling (dj-celery-panel, dj-redis-panel, etc) This project is aimed at creating better visibility of your project’s urlpatterns; URLs can grow unwieldy for large projects and it can be hard to understand exactly what is being surfaced by your project (whether by you or a third party app). Additionally, this project also includes a testing interface that can help replace other similar dependencies (Swagger UI) if they are being used solely for testing. Hope some of you can find some use out of this. Repo: <a href="https://github.com/yassi/dj-urls-panel">https://github.com/yassi/dj-urls-panel</a> pypi: <a href="https://pypi.org/project/dj-urls-panel/">https://pypi.org/project/dj-urls-panel/</a> docs: <a href="https://yassi.github.io/dj-urls-panel/">https://yassi.github.io/dj-urls-panel/</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/yassi_dev"> /u/yassi_dev </a> <a href="https://www.reddit.com/r/django/comments/1r30x1j/djurlspanel_visualize_and_test_django_url_routing/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r30x1j/djurlspanel_visualize_and_test_django_url_routing/">[comments]</a>

Hey team,
 I’ve just released dj-urls-panel
 It’s another panel in my series of django admin based tooling (dj-celery-panel, dj-redis-panel, etc)
 This project is aimed at creating better visibility of your project’s urlpatterns; URLs can grow unwieldy for large projects and it can be hard to understand exactly what is being surfaced by your project (whether by you or a third party app).
 Additionally, this project also includes a testing interface that can help replace other similar dependencies (Swagger UI) if they are being used solely for testing.
 Hope some of you can find some use out of this.
 Repo: https://github.com/yassi/dj-urls-panel
 pypi: https://pypi.org/project/dj-urls-panel/
 docs: https://yassi.github.io/dj-urls-panel/
    submitted by    /u/yassi_dev  
 [link]   [comments]

dj-urls-panel: Visualize and test Django URL routing inside the Django Admin

<div class="md">Presentation from September 2025 at PYCON UK. <blockquote> Find out how to run Django from a single file, with working views, models, admin and an API. We&#39;ll see how nanodjango makes it easy, how it&#39;s perfect for building everything from prototypes to production services, and why it&#39;s a powerful alternative to Flask and FastAPI. A Django project has lots of files and directories, which can be daunting for newcomers to the framework, and a burden for experienced developers. We&#39;re going to look at how Django normally uses this structure and why it makes sense, and how we can use Python to ignore that and load everything from a single file. We&#39;re going to look at how it can be useful for writing and sharing experiments and prototypes, and even building production sites and services. We&#39;ll see how nanodjango makes it easy to write and run single file Django scripts, and how its convert command can automatically refactor your single file into a full project as your code grows. We&#39;ll then work through some interesting real-world examples, and talk about some exciting new features. Richard is a full-stack developer at Lincoln Loop, specializing in Python and Django for the past 18 years. He started as a freelancer in 2004 and has previously been a team lead and CTO at a UK-based Django agency. He enjoys working on open-source projects and maintains several interesting libraries. Richard is an enthusiastic carpenter and maker, but sadly his skills rarely meet his ambitions. His other passion is traveling, although a young family means most adventures these days are near his home in the Cotwolds. </blockquote> From <a href="https://pretalx.com/pyconuk-2025/talk/7QZLCF/">https://pretalx.com/pyconuk-2025/talk/7QZLCF/</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Lokrea"> /u/Lokrea </a> <a href="https://www.youtube.com/watch?v=-cFvzE0Jt6c">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r2av2v/nanodjango_prototypes_sharing_and_services_full/">[comments]</a>

Presentation from September 2025 at PYCON UK.
  
Find out how to run Django from a single file, with working views, models, admin and an API. We'll see how nanodjango makes it easy, how it's perfect for building everything from prototypes to production services, and why it's a powerful alternative to Flask and FastAPI.
 A Django project has lots of files and directories, which can be daunting for newcomers to the framework, and a burden for experienced developers. We're going to look at how Django normally uses this structure and why it makes sense, and how we can use Python to ignore that and load everything from a single file.
 We're going to look at how it can be useful for writing and sharing experiments and prototypes, and even building production sites and services. We'll see how nanodjango makes it easy to write and run single file Django scripts, and how its convert command can automatically refactor your single file into a full project as your code grows.
 We'll then work through some interesting real-world examples, and talk about some exciting new features.
 Richard is a full-stack developer at Lincoln Loop, specializing in Python and Django for the past 18 years. He started as a freelancer in 2004 and has previously been a team lead and CTO at a UK-based Django agency. He enjoys working on open-source projects and maintains several interesting libraries.
 Richard is an enthusiastic carpenter and maker, but sadly his skills rarely meet his ambitions. His other passion is traveling, although a young family means most adventures these days are near his home in the Cotwolds.
  
From https://pretalx.com/pyconuk-2025/talk/7QZLCF/
    submitted by    /u/Lokrea  
 [link]   [comments]

nanodjango: Prototypes, Sharing and Services: Full Django in a Single File

<div class="md">Hi everyone, after 11 years of developing Django apps and finding myself copy-pasting the same devops code over and over, I finally took the time to open source it. <a href="https://github.com/mherrmann/djevops">Djevops </a>is a command-line tool for deploying Django apps to Linux VPSs. Unlike other solutions, it does not use Docker. This makes it faster and easier to work with. Take your Django app, add a $5 per month Linux VPS and you&#39;re good to go. Feedback would be appreciated :) Here&#39;s the full link again: <a href="https://github.com/mherrmann/djevops">https://github.com/mherrmann/djevops</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/mherrmann"> /u/mherrmann </a> <a href="https://www.reddit.com/r/django/comments/1r5l8p5/djevops_host_django_on_bare_metal/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r5l8p5/djevops_host_django_on_bare_metal/">[comments]</a>

Hi everyone,
 after 11 years of developing Django apps and finding myself copy-pasting the same devops code over and over, I finally took the time to open source it. Djevops is a command-line tool for deploying Django apps to Linux VPSs. Unlike other solutions, it does not use Docker. This makes it faster and easier to work with. Take your Django app, add a $5 per month Linux VPS and you're good to go.
 Feedback would be appreciated :) Here's the full link again: https://github.com/mherrmann/djevops
    submitted by    /u/mherrmann  
 [link]   [comments]

Djevops: Host Django on bare metal

<div class="md">Every time I start a new project, I spend the first few days setting up auth. Login, signup, email verification, password reset, token refresh... same thing every time. I finally got tired of it and built a proper starter template. Now I just clone and go. The stack: <ul> <li>Backend: Django 5.2 + DRF + SimpleJWT + Djoser</li> <li>Frontend: React 19 + Vite + TypeScript + Tailwind + Radix UI</li> </ul> What&#39;s included: Backend: <ul> <li>Custom User model with UUID primary keys and email-based login</li> <li>JWT auth with automatic token rotation and blacklisting</li> <li>Email verification flow (users must verify before logging in)</li> <li>Password reset with time-limited links</li> <li>Rate limiting</li> <li>Production security settings (HSTS, secure cookies, etc.)</li> <li>Separate dev/production settings (SQLite for dev, PostgreSQL for prod)</li> <li>Tests with pytest</li> </ul> Frontend: <ul> <li>Auth context + React Query (no Redux needed)</li> <li>Axios interceptors for automatic token refresh (with request queuing to handle race conditions)</li> <li>Protected and guest route guards</li> <li>&quot;Remember Me&quot; using localStorage vs sessionStorage</li> <li>All endpoints fully typed with TypeScript</li> </ul> The dev setup is zero-config - SQLite database, console email backend (emails print to your terminal). No need to set up Postgres or Mailgun just to test locally. I also wrote a detailed blog post walking through how everything works - the JWT flow, the token refresh queue pattern, the email verification setup, Djoser configuration, and production deployment: <a href="https://bhusalmanish.com.np/blog/posts/django-react-auth-starter.html">https://bhusalmanish.com.np/blog/posts/django-react-auth-starter.html</a> Repo: <a href="https://github.com/maniishbhusal/django-react-auth-starter">https://github.com/maniishbhusal/django-react-auth-starter</a> Live frontend preview: <a href="https://django-react-auth-starter.vercel.app/">https://django-react-auth-starter.vercel.app/</a> (backend isn&#39;t hosted, but you can see the UI) Would love feedback. PRs welcome if you spot improvements. <a href="https://preview.redd.it/gy5v5q31w2jg1.png?width=1752&amp;format=png&amp;auto=webp&amp;s=e94342fbaabc2e6c6acf30a393e5296a20e882b7">https://preview.redd.it/gy5v5q31w2jg1.png?width=1752&amp;format=png&amp;auto=webp&amp;s=e94342fbaabc2e6c6acf30a393e5296a20e882b7</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Ok-Childhood-5005"> /u/Ok-Childhood-5005 </a> <a href="https://www.reddit.com/r/django/comments/1r2vt1m/i_built_a_django_react_auth_starter_so_id_stop/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r2vt1m/i_built_a_django_react_auth_starter_so_id_stop/">[comments]</a>

Every time I start a new project, I spend the first few days setting up auth. Login, signup, email verification, password reset, token refresh... same thing every time.
 I finally got tired of it and built a proper starter template. Now I just clone and go.
 The stack:
  
Backend: Django 5.2 + DRF + SimpleJWT + Djoser
 Frontend: React 19 + Vite + TypeScript + Tailwind + Radix UI
  
What's included:
 Backend:
  
Custom User model with UUID primary keys and email-based login
 JWT auth with automatic token rotation and blacklisting
 Email verification flow (users must verify before logging in)
 Password reset with time-limited links
 Rate limiting
 Production security settings (HSTS, secure cookies, etc.)
 Separate dev/production settings (SQLite for dev, PostgreSQL for prod)
 Tests with pytest
  
Frontend:
  
Auth context + React Query (no Redux needed)
 Axios interceptors for automatic token refresh (with request queuing to handle race conditions)
 Protected and guest route guards
 "Remember Me" using localStorage vs sessionStorage
 All endpoints fully typed with TypeScript
  
The dev setup is zero-config - SQLite database, console email backend (emails print to your terminal). No need to set up Postgres or Mailgun just to test locally.
 I also wrote a detailed blog post walking through how everything works - the JWT flow, the token refresh queue pattern, the email verification setup, Djoser configuration, and production deployment: https://bhusalmanish.com.np/blog/posts/django-react-auth-starter.html
 Repo: https://github.com/maniishbhusal/django-react-auth-starter
 Live frontend preview: https://django-react-auth-starter.vercel.app/ (backend isn't hosted, but you can see the UI)
 Would love feedback. PRs welcome if you spot improvements.
 https://preview.redd.it/gy5v5q31w2jg1.png?width=1752&format=png&auto=webp&s=e94342fbaabc2e6c6acf30a393e5296a20e882b7
    submitted by    /u/Ok-Childhood-5005  
 [link]   [comments]

I built a Django + React auth starter so I'd stop rewriting the same login code every project

<div class="md">Hi everyone I’m trying to understand what the standard/best practice is for handling Django database migrations rollback in staging and production when using CI/CD. Scenario: <ul> <li>Django app deployed via CI/CD </li> <li>Deploy pipeline runs tests, then deploys to staging/prod </li> <li>As part of deployment we run <code>python</code> <a href="http://manage.py"><code>manage.py</code></a> <code>migrate</code> </li> <li>Sometimes after release, we find a serious issue and need to rollback the release (deploy previous version / git revert / rollback to last tag) </li> </ul> My confusion: Rolling back the code is straightforward, but migrations are already applied to the DB. <ul> <li>If migrations are additive (new columns/tables), old code might still work. </li> <li>But if migrations rename/drop fields/tables or include data migrations, code rollback can break or data can be lost. </li> <li>Django doesn’t automatically rollback DB schema when you rollback code. </li> </ul> Questions: <ul> <li>In real production setups, do you actually rollback migrations often? Or do you avoid it and prefer roll-forward fixes? </li> <li>What’s your rollback strategy in staging/prod? </li> <li>Restore DB snapshot/backup and rollback code? </li> <li>Keep migrations backward-compatible (expand/contract) so code rollback is safe? </li> <li>Use <code>python</code> <a href="http://manage.py"><code>manage.py</code></a> <code>migrate &lt;app&gt; &lt;previous_migration&gt;</code> in emergencies? </li> <li>Any CI/CD patterns you follow to make this safe? (feature flags, two-phase migrations, blue/green considerations, etc.) </li> </ul> I’d love to hear how teams handle this in practice and what you’d recommend as the safest approach. Thanks! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/ajay_reddyk"> /u/ajay_reddyk </a> <a href="https://www.reddit.com/r/django/comments/1r1t7xq/how_do_you_handle_django_migration_rollback_in/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r1t7xq/how_do_you_handle_django_migration_rollback_in/">[comments]</a>

Hi everyone 
 I’m trying to understand what the standard/best practice is for handling Django database migrations rollback in staging and production when using CI/CD.
 Scenario: 
 
Django app deployed via CI/CD 
 Deploy pipeline runs tests, then deploys to staging/prod 
 As part of deployment we run python manage.py migrate 
 Sometimes after release, we find a serious issue and need to rollback the release (deploy previous version / git revert / rollback to last tag) 
 
My confusion:
 Rolling back the code is straightforward, but migrations are already applied to the DB. 
 
If migrations are additive (new columns/tables), old code might still work. 
 But if migrations rename/drop fields/tables or include data migrations, code rollback can break or data can be lost. 
 Django doesn’t automatically rollback DB schema when you rollback code. 
 
Questions: 
 
In real production setups, do you actually rollback migrations often? Or do you avoid it and prefer roll-forward fixes? 
 What’s your rollback strategy in staging/prod? 
 Restore DB snapshot/backup and rollback code? 
 Keep migrations backward-compatible (expand/contract) so code rollback is safe? 
 Use python manage.py migrate <app> <previous_migration> in emergencies? 
 Any CI/CD patterns you follow to make this safe? (feature flags, two-phase migrations, blue/green considerations, etc.) 
 
I’d love to hear how teams handle this in practice and what you’d recommend as the safest approach.
 Thanks!
 submitted by /u/ajay_reddyk 
 [link] [comments]

How do you handle Django migration rollback in staging/prod with CI/CD?

<div class="md">Hi all, I&#39;m a solo dev that just finished a Django based project. Being a solo dev, I&#39;ve noticed that it&#39;s hard to get advice from other experienced devs on my projects and codebase in general. I&#39;m just starting out with my software career and would really appreciate getting some advice from more experienced devs. Things like preventing bad habits, anti-patterns and other stuff. Even the small nitpicks are fine with me. If you find yourself with time to spare and nothing else to do, please feel free to rip into my codebase here. <a href="https://github.com/JBK2116/collaboard-inc">Codebase</a> and <a href="http://collaboard.site">Live App</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/VermicelliFearless22"> /u/VermicelliFearless22 </a> <a href="https://www.reddit.com/r/django/comments/1r47u55/advice_from_experienced_django_devs/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r47u55/advice_from_experienced_django_devs/">[comments]</a>

Hi all, I'm a solo dev that just finished a Django based project. Being a solo dev, I've noticed that it's hard to get advice from other experienced devs on my projects and codebase in general. I'm just starting out with my software career and would really appreciate getting some advice from more experienced devs. Things like preventing bad habits, anti-patterns and other stuff. Even the small nitpicks are fine with me. If you find yourself with time to spare and nothing else to do, please feel free to rip into my codebase here.
 Codebase and Live App
    submitted by    /u/VermicelliFearless22  
 [link]   [comments]

Advice From Experienced Django Devs

<div class="md">Soo, I have a Django API that I use with NextJS as a frontend. I use JWT for auth, and I want to move to Django 6. I&#39;m currently on Django 5.2.11. Now, when I try to upgrade, I have two conflicts that prevent me from doing so: <code>django-celery-beat 2.8.1 requires Django&lt;6.0,&gt;=2.2, but you have django 6.0.2 which is incompatible.</code> <code>dj-rest-auth 7.0.2 requires Django&lt;6.0,&gt;=4.2, but you have django 6.0.2 which is incompatible.</code> I use Celery heavily in my app, and I use dj-rest-auth for social logins like Google and Discord. About the celery-beat package, I&#39;m not too concerned because of this issue here: <a href="https://github.com/celery/django-celery-beat/issues/977">https://github.com/celery/django-celery-beat/issues/977</a> And the fact that I see steps by the maintainer to move to Django 6+, so it will probably come eventually. My main concern is with dj-rest-auth, as it seems like the developer has lost interest in maintaining it. There is an open PR from someone in the community to allow support for Django 6: <a href="https://github.com/iMerica/dj-rest-auth/pull/719">https://github.com/iMerica/dj-rest-auth/pull/719</a> But it looks like it might sit there for quite some time — it&#39;s already been almost 3 weeks. Now my question is: is anyone else in the same situation? What do you use instead of dj-rest-auth for social logins? Has anyone here replaced it completely? If so, with what? Are you just using django-allauth directly and wiring it up yourself? Or something else entirely? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/KFSys"> /u/KFSys </a> <a href="https://www.reddit.com/r/django/comments/1r1uhrm/upgrading_to_django_6_what_are_people_using/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r1uhrm/upgrading_to_django_6_what_are_people_using/">[comments]</a>

Soo, I have a Django API that I use with NextJS as a frontend. I use JWT for auth, and I want to move to Django 6. I'm currently on Django 5.2.11.
 Now, when I try to upgrade, I have two conflicts that prevent me from doing so:
 django-celery-beat 2.8.1 requires Django<6.0,>=2.2, but you have django 6.0.2 which is incompatible.
 dj-rest-auth 7.0.2 requires Django<6.0,>=4.2, but you have django 6.0.2 which is incompatible.
 I use Celery heavily in my app, and I use dj-rest-auth for social logins like Google and Discord.
 About the celery-beat package, I'm not too concerned because of this issue here:
 https://github.com/celery/django-celery-beat/issues/977
 And the fact that I see steps by the maintainer to move to Django 6+, so it will probably come eventually.
 My main concern is with dj-rest-auth, as it seems like the developer has lost interest in maintaining it. There is an open PR from someone in the community to allow support for Django 6:
 https://github.com/iMerica/dj-rest-auth/pull/719
 But it looks like it might sit there for quite some time — it's already been almost 3 weeks.
 Now my question is: is anyone else in the same situation?
 What do you use instead of dj-rest-auth for social logins?
 Has anyone here replaced it completely? If so, with what?
 Are you just using django-allauth directly and wiring it up yourself?
 Or something else entirely?
 submitted by /u/KFSys 
 [link] [comments]

Upgrading to Django 6 – What are people using instead of dj-rest-auth for JWT + Social Login?

&#32; submitted by &#32; <a href="https://www.reddit.com/user/meagenvoss"> /u/meagenvoss </a> <a href="https://wagtail.org/blog/wagtail-nominated-for-two-cms-critic-awards/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r2bagp/wagtail_nominated_for_two_cms_critic_awards/">[comments]</a>

submitted by    /u/meagenvoss  
 [link]   [comments]

Wagtail nominated for TWO CMS Critic Awards! 🏆

<div class="md">Hi everyone! 👋 I’m exploring Django development and wanted to get a sense of the community’s experiences. A couple of things I’m curious about: <ol> <li>What are the biggest challenges or pain points you face when building projects with Django?</li> <li>When it comes to caching, do you typically stick with Django’s built-in caching framework (like <code>cache_page</code>, <code>Low-Level Cache API</code>, etc.), or do you implement a custom caching layer tailored to your app’s needs?</li> </ol> I’d love to hear your experiences, tips, or lessons learned. Thanks in advance! 🙏 </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/confessto"> /u/confessto </a> <a href="https://www.reddit.com/r/django/comments/1r5cscz/curious_about_challenges_and_caching_strategies/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r5cscz/curious_about_challenges_and_caching_strategies/">[comments]</a>

Hi everyone! 👋
 I’m exploring Django development and wanted to get a sense of the community’s experiences. A couple of things I’m curious about:
  
What are the biggest challenges or pain points you face when building projects with Django?
 When it comes to caching, do you typically stick with Django’s built-in caching framework (like cache_page, Low-Level Cache API, etc.), or do you implement a custom caching layer tailored to your app’s needs?
  
I’d love to hear your experiences, tips, or lessons learned. Thanks in advance! 🙏
    submitted by    /u/confessto  
 [link]   [comments]

Curious about challenges and caching strategies in Django

<div class="md">Hey everyone 👋 I’ve been working on a small Django tool called django-migration-audit. The idea is simple: Django assumes that if a migration is recorded as applied, the database schema matches. But in reality, that’s not always true. Things like: <ul> <li>modified migration files after they were applied</li> <li>fake-applied migrations (<code>--fake</code>)</li> <li>manual schema changes</li> <li>squashed migration mismatches</li> <li>restored databases from backups</li> </ul> can cause the database to drift away from what Django thinks happened. This tool performs two checks: <ol> <li>Trust Verification – Can we trust the migration history?</li> <li>Reality Check – Does the live schema actually match what migrations imply?</li> </ol> It’s read-only and currently meant for development, staging, CI, or forensic debugging. Example usage: <pre><code>python manage.py audit_migrations </code></pre> It’s still early, but I’m working toward making it stable and CI-friendly. Would love feedback on: <ul> <li>edge cases I should consider</li> <li>whether this is useful in real-world Django setups</li> <li>things you’ve seen break migrations in production</li> <li>have folks test it out and give feedback</li> </ul> Repo: <a href="https://github.com/JohananOppongAmoateng/django-migration-audit">https://github.com/JohananOppongAmoateng/django-migration-audit</a> Appreciate any thoughts 🙏 </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Dependent_Dig_7009"> /u/Dependent_Dig_7009 </a> <a href="https://www.reddit.com/r/django/comments/1r3ayxa/built_a_tool_to_audit_django_migration_drift/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r3ayxa/built_a_tool_to_audit_django_migration_drift/">[comments]</a>

Hey everyone 👋
 I’ve been working on a small Django tool called django-migration-audit.
 The idea is simple: Django assumes that if a migration is recorded as applied, the database schema matches. But in reality, that’s not always true.
 Things like:
  
modified migration files after they were applied
 fake-applied migrations (--fake)
 manual schema changes
 squashed migration mismatches
 restored databases from backups
  
can cause the database to drift away from what Django thinks happened.
 This tool performs two checks:
  
Trust Verification – Can we trust the migration history?
 Reality Check – Does the live schema actually match what migrations imply?
  
It’s read-only and currently meant for development, staging, CI, or forensic debugging.
 Example usage:
 python manage.py audit_migrations 
 It’s still early, but I’m working toward making it stable and CI-friendly.
 Would love feedback on:
  
edge cases I should consider
 whether this is useful in real-world Django setups
 things you’ve seen break migrations in production
 have folks test it out and give feedback
  
Repo: https://github.com/JohananOppongAmoateng/django-migration-audit
 Appreciate any thoughts 🙏
    submitted by    /u/Dependent_Dig_7009  
 [link]   [comments]

Built a tool to audit Django migration drift — looking for feedback

<div class="md">I&#39;m looking for a few open source projects in Django or DRF to try to make some contributions for practice. I have two years of experience working with DRF and would like to apply my skills to a new project. It could also benefit me to read other people&#39;s code and get new ideas from them. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/CallPsychological777"> /u/CallPsychological777 </a> <a href="https://www.reddit.com/r/django/comments/1r1izni/open_source_projects/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r1izni/open_source_projects/">[comments]</a>

I'm looking for a few open source projects in Django or DRF to try to make some contributions for practice. I have two years of experience working with DRF and would like to apply my skills to a new project. It could also benefit me to read other people's code and get new ideas from them.
    submitted by    /u/CallPsychological777  
 [link]   [comments]

Open source projects?

<div class="md">I’ve been working on a Japanese learning platform called Thank Japan, and I just implemented a new &quot;Kanji Time Attack&quot; mode. I wanted to share some of the Django-side logic I used for this. The Setup: Kanji Filtering: I used Regex in Django QuerySets to filter only entries that contain actual Kanji characters: qs.filter(kanji_name__regex=r&#39;[一-龠]&#39;). </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Thank_Japan"> /u/Thank_Japan </a> <a href="https://www.reddit.com/gallery/1r2r913">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r2r913/implementing_a_60_second_kanji_challenge_with/">[comments]</a>

I’ve been working on a Japanese learning platform called Thank Japan, and I just implemented a new "Kanji Time Attack" mode. I wanted to share some of the Django-side logic I used for this.
 The Setup:
 Kanji Filtering: I used Regex in Django QuerySets to filter only entries that contain actual Kanji characters: qs.filter(kanji_name__regex=r'[一-龠]').
    submitted by    /u/Thank_Japan  
 [link]   [comments]

Implementing a 60 second Kanji challenge with Django session-based timers

&#32; submitted by &#32; <a href="https://www.reddit.com/user/dwaxe"> /u/dwaxe </a> <a href="https://www.djangoproject.com/weblog/2026/feb/11/steering-council-2025-year-in-review/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r1zesn/django_steering_council_2025_year_in_review/">[comments]</a>

submitted by    /u/dwaxe  
 [link]   [comments]

Django Steering Council 2025 Year in Review

<div class="md">I’m developing an ERP system on Django and trying to design the product structure properly. Let’s take two examples. First example: Sunglasses. (Simple product) Classic Black Sunglasses. It has one price, one SKU, and one stock quantity. It looks like a simple product. Second example: Dress. (Variable product) Summer Dress with Size (S, M, L) and Color (Red, Blue). Each combination like Red–M or Blue–L has its own SKU, its own stock, and possibly its own price. In an ERP, sales and inventory need to track the exact sellable item. So I’m thinking: Should sales always store the SKU (variation) instead of the main product? For simple products, should we create one default variation internally and treat everything as a SKU? Or is it better to store stock and price directly in the product table for simple products? The goal is to keep inventory accurate, preserve correct sales history, and make the system scalable. I would like to hear how others have handled this in real ERP systems. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/sarathlal_n"> /u/sarathlal_n </a> <a href="https://www.reddit.com/r/django/comments/1r2mmmf/erp_simple_product_variable_product_and_database/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r2mmmf/erp_simple_product_variable_product_and_database/">[comments]</a>

I’m developing an ERP system on Django and trying to design the product structure properly.
 Let’s take two examples.
 First example: Sunglasses. (Simple product)
 Classic Black Sunglasses.
 It has one price, one SKU, and one stock quantity. It looks like a simple product.
 Second example: Dress. (Variable product)
 Summer Dress with Size (S, M, L) and Color (Red, Blue).
 Each combination like Red–M or Blue–L has its own SKU, its own stock, and possibly its own price.
 In an ERP, sales and inventory need to track the exact sellable item.
 So I’m thinking:
 Should sales always store the SKU (variation) instead of the main product?
 For simple products, should we create one default variation internally and treat everything as a SKU?
 Or is it better to store stock and price directly in the product table for simple products?
 The goal is to keep inventory accurate, preserve correct sales history, and make the system scalable.
 I would like to hear how others have handled this in real ERP systems.
    submitted by    /u/sarathlal_n  
 [link]   [comments]

ERP, Simple product, Variable product and Database modeling

<div class="md">Hello there, I&#39;d like to know what&#39;s your typical approach when working with common elements, such as buttons and input fields. Do you use css libraries and just copy/paste the elements each time you need them or maybe you create a separate template for each element and then include them? Or you just write the css by hand, targeting the elements directly? I&#39;m currently making the templates and overriting the built in django forms. It works fine, but the code looks ugly to me, each time i want to use the button i have to include the correct template and then wrap the include in &quot;with&quot; tag just to pass the arguments for the template. An ideal solution would be something similar to Vue&#39;s component slots, but the templates in Django work backwards. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/nfmon"> /u/nfmon </a> <a href="https://www.reddit.com/r/django/comments/1r042a8/how_are_you_dealing_with_reusable_elements/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r042a8/how_are_you_dealing_with_reusable_elements/">[comments]</a>

Hello there,
 I'd like to know what's your typical approach when working with common elements, such as buttons and input fields. Do you use css libraries and just copy/paste the elements each time you need them or maybe you create a separate template for each element and then include them? Or you just write the css by hand, targeting the elements directly?
 I'm currently making the templates and overriting the built in django forms. It works fine, but the code looks ugly to me, each time i want to use the button i have to include the correct template and then wrap the include in "with" tag just to pass the arguments for the template. An ideal solution would be something similar to Vue's component slots, but the templates in Django work backwards.
    submitted by    /u/nfmon  
 [link]   [comments]

How are you dealing with reusable elements?

<div class="md">&#x200B; I’ve just released django-ml-audit, a reusable Django app to keep a per-prediction audit trail for ML models running inside Django/DRF APIs. I’m looking for feedback on whether this solves a real pain for you and how the API should evolve. The problem Once a model is in production, questions like these show up: “A user complained about a decision last month – can we replay exactly what the model did for that request?” “Which model version made this prediction, with which inputs and confidence?” “We compute SHAP/LIME offline, but where do we store explanations for real production predictions?” “How do we keep enough context to debug while not dumping raw PII into logs?” Most teams end up with ad-hoc logging or custom tables per project, which makes audits and incident reviews painful. What django-ml-audit does It’s a Django app that gives you: A standard schema for prediction events: model + version, environment, redacted features, outputs, confidence, status, latency, trace ID, etc. A separate RequestingActor model to track who/what called the model (user, service, tenant, IP, user agent). An Explanation model to attach JSON payloads (e.g. SHAP) plus a human-readable summary to each prediction. A field-based redaction layer for feature payloads: Configurable allowlist/denylist. Conservative defaults for keys like email, password, token, credit_card, etc. Built-in Django admin and read-only DRF endpoints to browse and filter predictions: List predictions with filters for model, time range, environment, actor, confidence range, and “has explanation”. Retrieve a single prediction with its model, actor, and explanation attached. The idea is: months later, for any given prediction, you can answer “what happened here and why?” without reverse-engineering logs. Example use case (high level) A typical use case is a fraud detection API in Django: Every time the API scores a transaction, it records: The model version that made the decision. Redacted features (e.g. amount, country, but masked email/ID). Outputs, confidence, and decision outcome (flagged / clean). The user or service that requested it, plus optional tenant. A separate background job (or the same view) can compute an explanation (SHAP, reason codes, etc.) and attach it. Later, if a regulator or internal reviewer asks about a specific transaction, you can pull a single prediction record with full context and explanation instead of scraping logs. How to try it PyPI: django-ml-audit Add ml_audit and rest_framework to INSTALLED_APPS, run migrations, mount /api/ml-audit/ in urls.py. Start logging predictions via a small service function (record_prediction_event) and optionally attach explanations. Repo &amp; docs: GitHub: <a href="https://github.com/RJ-Gamer/ml-audit">https://github.com/RJ-Gamer/ml-audit</a> PyPI: <a href="https://pypi.org/project/django-ml-audit/">https://pypi.org/project/django-ml-audit/</a> Feedback I’m looking for Does per-prediction auditability solve a real problem in your Django/ML projects? What extra fields or behaviors would you want in a production-ready audit trail? Would you prioritize: Multiple explanations per prediction, Better export/reporting for audits, or A minimal web UI to browse and compare predictions? Any thoughts, criticism, or “this would be useful if it also did X” are very welcome. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/disizrj"> /u/disizrj </a> <a href="https://www.reddit.com/r/django/comments/1r3t89p/i_built_djangomlaudit_a_django_app_for_auditing/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r3t89p/i_built_djangomlaudit_a_django_app_for_auditing/">[comments]</a>

​
 I’ve just released django-ml-audit, a reusable Django app to keep a per-prediction audit trail for ML models running inside Django/DRF APIs.
 I’m looking for feedback on whether this solves a real pain for you and how the API should evolve.
 The problem
 Once a model is in production, questions like these show up:
 “A user complained about a decision last month – can we replay exactly what the model did for that request?”
 “Which model version made this prediction, with which inputs and confidence?”
 “We compute SHAP/LIME offline, but where do we store explanations for real production predictions?”
 “How do we keep enough context to debug while not dumping raw PII into logs?”
 Most teams end up with ad-hoc logging or custom tables per project, which makes audits and incident reviews painful.
 What django-ml-audit does
 It’s a Django app that gives you:
 A standard schema for prediction events: model + version, environment, redacted features, outputs, confidence, status, latency, trace ID, etc.
 A separate RequestingActor model to track who/what called the model (user, service, tenant, IP, user agent).
 An Explanation model to attach JSON payloads (e.g. SHAP) plus a human-readable summary to each prediction.
 A field-based redaction layer for feature payloads:
 Configurable allowlist/denylist.
 Conservative defaults for keys like email, password, token, credit_card, etc.
 Built-in Django admin and read-only DRF endpoints to browse and filter predictions:
 List predictions with filters for model, time range, environment, actor, confidence range, and “has explanation”.
 Retrieve a single prediction with its model, actor, and explanation attached.
 The idea is: months later, for any given prediction, you can answer “what happened here and why?” without reverse-engineering logs.
 Example use case (high level)
 A typical use case is a fraud detection API in Django:
 Every time the API scores a transaction, it records:
 The model version that made the decision.
 Redacted features (e.g. amount, country, but masked email/ID).
 Outputs, confidence, and decision outcome (flagged / clean).
 The user or service that requested it, plus optional tenant.
 A separate background job (or the same view) can compute an explanation (SHAP, reason codes, etc.) and attach it.
 Later, if a regulator or internal reviewer asks about a specific transaction, you can pull a single prediction record with full context and explanation instead of scraping logs.
 How to try it
 PyPI: django-ml-audit
 Add ml_audit and rest_framework to INSTALLED_APPS, run migrations, mount /api/ml-audit/ in urls.py.
 Start logging predictions via a small service function (record_prediction_event) and optionally attach explanations.
 Repo & docs:
 GitHub: https://github.com/RJ-Gamer/ml-audit
 PyPI: https://pypi.org/project/django-ml-audit/
 Feedback I’m looking for
 Does per-prediction auditability solve a real problem in your Django/ML projects?
 What extra fields or behaviors would you want in a production-ready audit trail?
 Would you prioritize:
 Multiple explanations per prediction,
 Better export/reporting for audits, or
 A minimal web UI to browse and compare predictions?
 Any thoughts, criticism, or “this would be useful if it also did X” are very welcome.
    submitted by    /u/disizrj  
 [link]   [comments]

I built django-ml-audit: a Django app for auditing ML predictions (feedback welcome)

<div class="md">Hi everyone, I’m currently starting my first Django project — a Recipe Keeper — and I’m trying to think through the structure properly before I go too far. Right now my project is structured like this: <a href="https://preview.redd.it/k9nj53j5bwig1.png?width=314&amp;format=png&amp;auto=webp&amp;s=4b5796841770dd19e4f38819be1e78785c0a89bd">current structure</a> <ul> <li>accounts → handles authentication and login-related functionality</li> <li>core → landing page / dashboard after successful login</li> <li>recipes → recipe-related views and templates (e.g. displaying a single recipe)</li> </ul> I’m trying to keep responsibilities separated and avoid mixing layout, logic and domain concerns. Now I’m thinking about the following: I want to include a Bootstrap 5 navbar (<a href="https://getbootstrap.com/docs/5.3/components/navbar/#">Offcanvas navbar</a>) that will be visible across the whole application. It should contain navigation links (get back to the landingpage, create a new recipe, search a recipe and get recipes based on ingredients). This raises two questions for me: <ol> <li>Does this overall app structure make sense from an architectural perspective, especially for a growing project?</li> <li>How should I properly handle global layout components like a navbar in Django? <ul> <li>Should it live in one of the existing apps?</li> <li>Should I create a separate app for layout-related components?</li> <li>Or should it be handled via a global <code>base.html</code> and shared templates directory?</li> </ul></li> </ol> I want to build this in a clean and scalable way rather than just making it “work”. Would really appreciate feedback on best practices and how more experienced Django developers usually approach this. Thanks in advance! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/DaveDarell"> /u/DaveDarell </a> <a href="https://www.reddit.com/r/django/comments/1r22rei/structuring_my_first_django_project_apps_and/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r22rei/structuring_my_first_django_project_apps_and/">[comments]</a>

Hi everyone,
 I’m currently starting my first Django project — a Recipe Keeper — and I’m trying to think through the structure properly before I go too far.
 Right now my project is structured like this:
 current structure
  
accounts → handles authentication and login-related functionality
 core → landing page / dashboard after successful login
 recipes → recipe-related views and templates (e.g. displaying a single recipe)
  
I’m trying to keep responsibilities separated and avoid mixing layout, logic and domain concerns.
 Now I’m thinking about the following:
 I want to include a Bootstrap 5 navbar (Offcanvas navbar) that will be visible across the whole application. It should contain navigation links (get back to the landingpage, create a new recipe, search a recipe and get recipes based on ingredients).
 This raises two questions for me:
  
Does this overall app structure make sense from an architectural perspective, especially for a growing project?
 How should I properly handle global layout components like a navbar in Django? 
 Should it live in one of the existing apps?
 Should I create a separate app for layout-related components?
 Or should it be handled via a global base.html and shared templates directory?
 
  
I want to build this in a clean and scalable way rather than just making it “work”.
 Would really appreciate feedback on best practices and how more experienced Django developers usually approach this.
 Thanks in advance!
    submitted by    /u/DaveDarell  
 [link]   [comments]

Structuring my first Django project – apps and global layout

<div class="md">I built and published a Django audit library after discovering why signal-based solutions fail in compliance-heavy systems. This is a detailed write-up of: - The production incident that started it - Why signals can&#39;t capture intent - The architecture that fixed it - Lessons from publishing to PyPI Link: <a href="https://building-django-system-audit.hashnode.dev/building-django-system-audit-why-djangos-signals-break-audit-trails-and-how-to-fix-it">https://building-django-system-audit.hashnode.dev/building-django-system-audit-why-djangos-signals-break-audit-trails-and-how-to-fix-it</a> Happy to answer questions about the design decisions! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/disizrj"> /u/disizrj </a> <a href="https://www.reddit.com/r/django/comments/1r1ulbs/building_djangosystemaudit_why_djangos_signals/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r1ulbs/building_djangosystemaudit_why_djangos_signals/">[comments]</a>

I built and published a Django audit library after discovering why signal-based solutions fail in compliance-heavy systems.
 This is a detailed write-up of:
 - The production incident that started it
 - Why signals can't capture intent
 - The architecture that fixed it
 - Lessons from publishing to PyPI
 Link: 
 https://building-django-system-audit.hashnode.dev/building-django-system-audit-why-djangos-signals-break-audit-trails-and-how-to-fix-it
 Happy to answer questions about the design decisions!
    submitted by    /u/disizrj  
 [link]   [comments]

Building django-system-audit: Why Django's Signals Break Audit Trails

<div class="md">I&#39;m build pure Django app for sports event registration, and RSVPs. The site is <a href="https://registerfor.events">https://registerfor.events</a> It&#39;s simple right now and I&#39;m going a Craigslist model. I like the direction that it&#39;s going but it seems bland. I&#39;ve build with Django before, but it&#39;s been about 4 years since I&#39;ve used it without any JS anywhere. I like how fast/predictable it is to develop, but I worry about getting users interested with the retro design and feel. For example, I have direct messaging that works and feels like it&#39;s from 2005. I could rebuild it as a service to be much nicer with something else, but I&#39;m not sure that focusing on that rather then core features that would actually get used is really the way to go. So, does anyone build with pure Django? Just templates and form and view? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/ExtensionBreath1262"> /u/ExtensionBreath1262 </a> <a href="https://www.reddit.com/r/django/comments/1r5yj51/do_you_build_with_progressive_enhancements_in_mind/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r5yj51/do_you_build_with_progressive_enhancements_in_mind/">[comments]</a>

I'm build pure Django app for sports event registration, and RSVPs. The site is https://registerfor.events 
 It's simple right now and I'm going a Craigslist model. I like the direction that it's going but it seems bland. I've build with Django before, but it's been about 4 years since I've used it without any JS anywhere.
 I like how fast/predictable it is to develop, but I worry about getting users interested with the retro design and feel. For example, I have direct messaging that works and feels like it's from 2005. I could rebuild it as a service to be much nicer with something else, but I'm not sure that focusing on that rather then core features that would actually get used is really the way to go.
 So, does anyone build with pure Django? Just templates and form and view?
    submitted by    /u/ExtensionBreath1262  
 [link]   [comments]

Do you build with progressive enhancements in mind?

&#32; submitted by &#32; <a href="https://www.reddit.com/user/jadd_logs"> /u/jadd_logs </a> <a href="/r/learnprogramming/comments/1r2wdko/how_do_you_create_er_diagrams/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r2wg2w/how_do_you_create_er_diagrams/">[comments]</a>

How do you create ER Diagrams?

<div class="md">I&#39;m new to Django but I know python. I have a project in mind. But when I think about starting to build it with only the documentation I feel very overwhelmed. Even when I&#39;ve broken it down to a very basic MVP, I don&#39;t know where to start. When I was learning to code, I used videos which helped and I did other people&#39;s tutorial projects. But I don&#39;t want to start doing that all over. I want to dive right into building my own project. Could someone just give me some pointers to set me on the right path? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Neil-Amstrong"> /u/Neil-Amstrong </a> <a href="https://www.reddit.com/r/django/comments/1r1vubg/how_do_i_learn_django_the_old_school_way_with/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r1vubg/how_do_i_learn_django_the_old_school_way_with/">[comments]</a>

I'm new to Django but I know python. I have a project in mind. But when I think about starting to build it with only the documentation I feel very overwhelmed. Even when I've broken it down to a very basic MVP, I don't know where to start. When I was learning to code, I used videos which helped and I did other people's tutorial projects. But I don't want to start doing that all over. I want to dive right into building my own project.
 Could someone just give me some pointers to set me on the right path?
    submitted by    /u/Neil-Amstrong  
 [link]   [comments]

How do I learn Django the old school way with only its documentation?

<div class="md">is this overkill? i cant think of any way to make it better, except maybe to use jsonField to store genres and platforms etc..? but since i want to support filters based on genres, platforms, gamemodes etc i think its better to have a table for each? <pre><code>class VideoGame(models.Model): title = models.CharField(max_length=200) release_date = models.DateField(null=True) score = models.DecimalField(max_digits=5, decimal_places=2) overview = models.TextField(null=True) class Meta: ordering = [&#39;title&#39;] def __str__(self): return self.title class VideoGameGenre(models.Model): video_game = models.ManyToManyField(VideoGame) genre = models.CharField(max_length=50) def __str__(self): return self.genre class VideoGamePlatform(models.Model): video_game = models.ManyToManyField(VideoGame) platform = models.CharField(max_length=50) def __str__(self): return self.platform class VideoGameAgeRating(models.Model): video_game = models.ManyToManyField(VideoGame) age_rating = models.CharField(max_length=20) def __str__(self): return self.age_rating class VideoGameMediaContent(models.Model): video_game = models.ForeignKey(VideoGame, on_delete=models.CASCADE) </code></pre> there are other tables im thinking of like game_modes or games by a certain developer/publisher， it feels like its too much and that there could be a btter way to go about this </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/MEHDII__"> /u/MEHDII__ </a> <a href="https://www.reddit.com/r/django/comments/1r1rddh/separate_models_for_the_same_object/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r1rddh/separate_models_for_the_same_object/">[comments]</a>

is this overkill? i cant think of any way to make it better, except maybe to use jsonField to store genres and platforms etc..? but since i want to support filters based on genres, platforms, gamemodes etc i think its better to have a table for each? 
 class VideoGame(models.Model): title = models.CharField(max_length=200) release_date = models.DateField(null=True) score = models.DecimalField(max_digits=5, decimal_places=2) overview = models.TextField(null=True) class Meta: ordering = ['title'] def __str__(self): return self.title class VideoGameGenre(models.Model): video_game = models.ManyToManyField(VideoGame) genre = models.CharField(max_length=50) def __str__(self): return self.genre class VideoGamePlatform(models.Model): video_game = models.ManyToManyField(VideoGame) platform = models.CharField(max_length=50) def __str__(self): return self.platform class VideoGameAgeRating(models.Model): video_game = models.ManyToManyField(VideoGame) age_rating = models.CharField(max_length=20) def __str__(self): return self.age_rating class VideoGameMediaContent(models.Model): video_game = models.ForeignKey(VideoGame, on_delete=models.CASCADE) 
 there are other tables im thinking of like game_modes or games by a certain developer/publisher， it feels like its too much and that there could be a btter way to go about this
    submitted by    /u/MEHDII__  
 [link]   [comments]

separate models for the same object

<div class="md">Im receiving data form the IGDB api which is something around 500k video games according to their site, storing it in my database, but how do i keep my database up to date with the api? In case of new game releases or any other update, and if the answer is to just query the api periodically, how to know if something actually changed (new data), and if something did change do i just save everything to the database again, even the old data will be overwitten? Sorry i&#39;m new to this, couldn&#39;t find a clear answer online </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/MEHDII__"> /u/MEHDII__ </a> <a href="https://www.reddit.com/r/django/comments/1r19nrz/keeping_data_fetched_from_a_3rd_party_api_in_sync/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1r19nrz/keeping_data_fetched_from_a_3rd_party_api_in_sync/">[comments]</a>

Im receiving data form the IGDB api which is something around 500k video games according to their site, storing it in my database, but how do i keep my database up to date with the api? In case of new game releases or any other update, and if the answer is to just query the api periodically, how to know if something actually changed (new data), and if something did change do i just save everything to the database again, even the old data will be overwitten? Sorry i'm new to this, couldn't find a clear answer online
    submitted by    /u/MEHDII__  
 [link]   [comments]

Keeping data fetched from a 3rd party api in sync

<div class="md">Hey everyone 👋 I just published my first PyPI package 🎉<a href="https://pypi.org/project/sqlite-opus/">sqlite-opus</a> sqlite-opus is a simple tool to work with SQLite in a web UI. It’s built for simplicity and easy integration — just install it in your Flask project and start querying your database from the browser. Git repo here: <a href="https://github.com/hungle00/sqlite-opus">https://github.com/hungle00/sqlite-opus</a> Current features: <ul> <li>Connect to DB and view tables, columns, indexes, etc.</li> <li>Execute SQL queries</li> <li>Export query results to CSV</li> </ul> More features coming soon. Hope you find it useful! 🚀 </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/lmh-cadenza-093"> /u/lmh-cadenza-093 </a> <a href="https://www.reddit.com/r/flask/comments/1r55ut9/sqliteopus_the_web_ui_for_sqlite_query_on_flask/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1r55ut9/sqliteopus_the_web_ui_for_sqlite_query_on_flask/">[comments]</a>

Hey everyone 👋
 I just published my first PyPI package 🎉sqlite-opus
 sqlite-opus is a simple tool to work with SQLite in a web UI. It’s built for simplicity and easy integration — just install it in your Flask project and start querying your database from the browser.
 Git repo here: https://github.com/hungle00/sqlite-opus
 Current features:
  
Connect to DB and view tables, columns, indexes, etc.
 Execute SQL queries
 Export query results to CSV
  
More features coming soon. Hope you find it useful! 🚀
    submitted by    /u/lmh-cadenza-093  
 [link]   [comments]

sqlite-opus - The web UI for SQLite query on Flask

<table> <tr><td> <a href="https://www.reddit.com/r/flask/comments/1r19ijx/after_25_years_using_orms_i_switched_to_raw/"> <img src="https://external-preview.redd.it/O-jbP30hAQEHSBZgJG3bYvkz3xQHDCdMbbkcNbQD-fw.jpeg?width=640&amp;crop=smart&amp;auto=webp&amp;s=eab4e568d39311fd17afeedd7355b641622017b2" alt="After 25+ years using ORMs, I switched to raw queries + dataclasses. I think it's the move." title="After 25+ years using ORMs, I switched to raw queries + dataclasses. I think it's the move." /> </a> </td><td> &#32; submitted by &#32; <a href="https://www.reddit.com/user/mikeckennedy"> /u/mikeckennedy </a> <a href="/r/Python/comments/1r19hu1/after_25_years_using_orms_i_switched_to_raw/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1r19ijx/after_25_years_using_orms_i_switched_to_raw/">[comments]</a> </td></tr></table>

submitted by    /u/mikeckennedy  
 [link]   [comments]

After 25+ years using ORMs, I switched to raw queries + dataclasses. I think it's the move.

<div class="md">I&#39;m trying to make a Flask server backend to interface with a Godot game. So far I&#39;ve only created the most basic Flask app possible: <pre><code>from flask import Flask app = Flask(__name__) @app.route(&#39;/&#39;) def index(): return &#39;Hello World!&#39; if __name__ == &#39;__main__&#39;: app.run(debug=True,host=&#39;localhost&#39;) </code></pre> But, for some reason, the page gets stuck loading infinitely. However, when I restart the app by clicking &#39;run&#39; again, it works, after printing this into the shell: <pre><code> * Debugger is active! * Debugger PIN: xxx-xxx-xxx 127.0.0.1 - - [11/Feb/2026 23:14:08] &quot;GET / HTTP/1.1&quot; 200 - 127.0.0.1 - - [11/Feb/2026 23:14:17] &quot;GET / HTTP/1.1&quot; 200 - </code></pre> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Ready-Ideal-3298"> /u/Ready-Ideal-3298 </a> <a href="https://www.reddit.com/r/flask/comments/1r2jrm6/flask_app_will_only_load_pages_after_restarting/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1r2jrm6/flask_app_will_only_load_pages_after_restarting/">[comments]</a>

I'm trying to make a Flask server backend to interface with a Godot game. So far I've only created the most basic Flask app possible:
 from flask import Flask app = Flask(__name__) @app.route('/') def index(): return 'Hello World!' if __name__ == '__main__': app.run(debug=True,host='localhost') 
 But, for some reason, the page gets stuck loading infinitely. However, when I restart the app by clicking 'run' again, it works, after printing this into the shell:
  * Debugger is active! * Debugger PIN: xxx-xxx-xxx 127.0.0.1 - - [11/Feb/2026 23:14:08] "GET / HTTP/1.1" 200 - 127.0.0.1 - - [11/Feb/2026 23:14:17] "GET / HTTP/1.1" 200 - 
    submitted by    /u/Ready-Ideal-3298  
 [link]   [comments]

Flask app will only load pages after restarting

<div class="md">Hi everyone, in my project I use flask as my rest api, with a layered architecture with controller, service, and repository. Now, since the repository doesn&#39;t perform commits, but adds, removes or modifies entities through the sqlalchemy session, I want to understand how to handle the commit. Specifically, I would like to create something like spring boot&#39;s Transactional decorator, where with the default settings (propagation required) if decorated service A calls decorated service B, service B uses service A&#39;s session, only committing at the end of all operations. Has anyone done something like this before? Or is there a better way to handle these situations? Thanks in advance. Example of base repository (it is extended by other repositories): <code>class BaseRepository(Generic[T]):</code> <code>model: type[T]</code> <code>def __init__(self, db: SQLAlchemy) -&gt; None:</code> <code>self.db = db</code> <code>def get_all(self) -&gt; Sequence[T]:</code> <code>stmt = select(self.model)</code> <code>res = self.db.session.execute(stmt).scalars().all()</code> <code>return res</code> <code>def save(self, obj: T) -&gt; T:</code> <code>if object_session(obj) is None: # If is new the session associated with the object will be None</code> <code>self.db.session.add(obj)</code> <code>self.db.session.flush()</code> <code>return obj</code> <code>def get_by_id(self, id: int) -&gt; T | None:</code> <code>stmt = select(self.model).where(self.model.id == id)</code> <code>obj = self.db.session.execute(stmt).scalar_one_or_none()</code> <code>return obj</code> <code>def delete_by_id(self, id: int) -&gt; T | None:</code> <code>stmt = select(self.model).where(self.model.id == id)</code> <code>obj = self.db.session.execute(stmt).scalar_one_or_none()</code> <code>if obj:</code> <code>self.db.session.delete(obj)</code> <code>return obj</code> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Substantial_Waltz951"> /u/Substantial_Waltz951 </a> <a href="https://www.reddit.com/r/flask/comments/1r352j6/attempt_to_create_a_transactional_spring_boot/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1r352j6/attempt_to_create_a_transactional_spring_boot/">[comments]</a>

Hi everyone, in my project I use flask as my rest api, with a layered architecture with controller, service, and repository. Now, since the repository doesn't perform commits, but adds, removes or modifies entities through the sqlalchemy session, I want to understand how to handle the commit. Specifically, I would like to create something like spring boot's Transactional decorator, where with the default settings (propagation required) if decorated service A calls decorated service B, service B uses service A's session, only committing at the end of all operations. Has anyone done something like this before? Or is there a better way to handle these situations? Thanks in advance.
 Example of base repository (it is extended by other repositories):
 class BaseRepository(Generic[T]):
 model: type[T]
 def __init__(self, db: SQLAlchemy) -> None:
 self.db = db
 def get_all(self) -> Sequence[T]:
 stmt = select(self.model)
 res = self.db.session.execute(stmt).scalars().all()
 return res
 def save(self, obj: T) -> T:
 if object_session(obj) is None: # If is new the session associated with the object will be None
 self.db.session.add(obj)
 self.db.session.flush()
 return obj
 def get_by_id(self, id: int) -> T | None:
 stmt = select(self.model).where(self.model.id == id)
 obj = self.db.session.execute(stmt).scalar_one_or_none()
 return obj
 def delete_by_id(self, id: int) -> T | None:
 stmt = select(self.model).where(self.model.id == id)
 obj = self.db.session.execute(stmt).scalar_one_or_none()
 if obj:
 self.db.session.delete(obj)
 return obj
    submitted by    /u/Substantial_Waltz951  
 [link]   [comments]

Hello, Python

Python Jobs 💼