<div class="md">Hi!, I have a Django project and I want to track user activity metrics like DAU, WAU, MAU, is there any way to do that ?. <a href="https://www.reddit.com/submit/?source_id=t3_1sf8q8e&amp;composer_entry=crosspost_prompt"></a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/EnvironmentalMind996"> /u/EnvironmentalMind996 </a> <a href="https://www.reddit.com/r/djangolearning/comments/1sf8rww/django_analytics/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1sf8rww/django_analytics/">[comments]</a>

Hi!, I have a Django project and I want to track user activity metrics like DAU, WAU, MAU, is there any way to do that ?.
 
    submitted by    /u/EnvironmentalMind996  
 [link]   [comments]

Django analytics

<div class="md">Selfteaching backend engineering with python,django...I do not have any cs books or anything. just AI agents and youtube help me to understand the basics and the principles ..I never enjoyed coding even during my college days or more accurately, I never gave it enough focus ..but now I want to give it fair attempt .who knows what future holds. maybe only strong engineer will remain or maybe there will be more job due to AI. But I just give myself a chance to learn, grow, to master a skill .Even if it does not immediately translate into value, the process will still matter. Every skill developed and every effort made contributes to the future in some form....so even in the middle of anxiety,doubt and pressure I will continue learning. Not because it is easy but because it is necessary . .if I can try others can too </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/S7jstnameit"> /u/S7jstnameit </a> <a href="/r/django/comments/1sahi0g/learning_python_django/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1sahlyk/learning_backend_engineering_with_python/">[comments]</a>

Selfteaching backend engineering with python,django...I do not have any cs books or anything. just AI agents and youtube help me to understand the basics and the principles ..I never enjoyed coding even during my college days or more accurately, I never gave it enough focus ..but now I want to give it fair attempt .who knows what future holds. maybe only strong engineer will remain or maybe there will be more job due to AI. But I just give myself a chance to learn, grow, to master a skill .Even if it does not immediately translate into value, the process will still matter. Every skill developed and every effort made contributes to the future in some form....so even in the middle of anxiety,doubt and pressure I will continue learning. Not because it is easy but because it is necessary . .if I can try others can too
    submitted by    /u/S7jstnameit  
 [link]   [comments]

Learning Backend engineering with python django,What more should add to that guys?

<div class="md">hey guys, I use gunicorn with gthread. Since flask is sync. I wanna know how many concurrent requests do I get over time, and if it every exceeds worker*threads, in my case 10*10=100. and if I need to add more threads. How can I monitor it? I use flask with gunicorn, docker, nginx in front. Also have netadata enabled. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Consistent_Tutor_597"> /u/Consistent_Tutor_597 </a> <a href="https://www.reddit.com/r/flask/comments/1sasuox/how_can_i_monitor_how_many_requests_am_i/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1sasuox/how_can_i_monitor_how_many_requests_am_i/">[comments]</a>

hey guys, I use gunicorn with gthread. Since flask is sync. I wanna know how many concurrent requests do I get over time, and if it every exceeds worker*threads, in my case 10*10=100. and if I need to add more threads. How can I monitor it? 
 I use flask with gunicorn, docker, nginx in front. Also have netadata enabled. 
    submitted by    /u/Consistent_Tutor_597  
 [link]   [comments]

How can I monitor how many requests am I processing rn and how many are waiting?

<div class="md">I just open-sourced smart-ratelimiter, a production-ready Python rate limiting library. Would love feedback from the community. What it does: Provides rate limiting for Python APIs and services. Most libraries give you one algorithm — this gives you six, all behind a consistent API with swappable storage backends. Algorithms: Fixed Window, Sliding Window Log, Sliding Window Counter Token Bucket, Leaky Bucket Adaptive Hybrid — auto-tightens under high load, relaxes when quiet. No manual tuning. Backends: In-memory · Redis · SQLite Usage: pip install smart-ratelimiter from ratelimiter import AdaptiveRateLimiter, MemoryBackend limiter = AdaptiveRateLimiter(MemoryBackend(), limit=100, window=60) result = limiter.is_allowed(&quot;user:42&quot;) Links: GitHub: <a href="https://github.com/himanshu9209/ratelimiter">https://github.com/himanshu9209/ratelimiter</a> PyPI: <a href="https://pypi.org/project/smart-ratelimiter/">https://pypi.org/project/smart-ratelimiter/</a> Zero required dependencies. MIT licensed. Contributions welcome! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Away-Range-5276"> /u/Away-Range-5276 </a> <a href="https://www.reddit.com/r/flask/comments/1seiowa/i_built_a_productionready_python_rate_limiter/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1seiowa/i_built_a_productionready_python_rate_limiter/">[comments]</a>

I just open-sourced smart-ratelimiter, a production-ready Python rate limiting library. Would love feedback from the community.
 What it does:
 Provides rate limiting for Python APIs and services. Most libraries give you one algorithm — this gives you six, all behind a consistent API with swappable storage backends.
 Algorithms:
 Fixed Window, Sliding Window Log, Sliding Window Counter
 Token Bucket, Leaky Bucket
 Adaptive Hybrid — auto-tightens under high load, relaxes when quiet. No manual tuning.
 Backends: In-memory · Redis · SQLite
 Usage:
 pip install smart-ratelimiter
 from ratelimiter import AdaptiveRateLimiter, MemoryBackend
 limiter = AdaptiveRateLimiter(MemoryBackend(), limit=100, window=60)
 result = limiter.is_allowed("user:42")
 Links:
 GitHub: https://github.com/himanshu9209/ratelimiter
 PyPI: https://pypi.org/project/smart-ratelimiter/
 Zero required dependencies. MIT licensed. Contributions welcome!
    submitted by    /u/Away-Range-5276  
 [link]   [comments]

I built a production-ready Python rate limiter with 6 algorithms and adaptive load-sensing.

<div class="md">I’ve been building with FastAPI for a while now and I’m curious how people are really handling background work beyond simple demos. The docs show <code>BackgroundTasks</code>, but that feels pretty limited once things get even slightly complex. Some situations I keep running into: <ul> <li>sending emails, notifications, webhooks</li> <li>retrying failed tasks</li> <li>long running async jobs</li> <li>tasks that depend on other tasks</li> <li>needing visibility into what’s running or failing</li> </ul> Right now it feels like there are a few options: <ul> <li>stick with <code>BackgroundTasks</code></li> <li>use something like Celery or RQ</li> <li>or just push everything into a message broker</li> </ul> But none of these feel very “FastAPI-native” or simple. So I’m wondering: <ul> <li>What are you using in production?</li> <li>Are you staying fully async or mixing in workers?</li> <li>How are you handling retries and failures?</li> <li>Do you have any visibility into tasks or is it just logs and hope?</li> </ul> Would be interesting to hear what actually works in real systems, not just tutorials. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Educational-Hope960"> /u/Educational-Hope960 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sbnurr/how_are_you_actually_managing_backgroundasync/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sbnurr/how_are_you_actually_managing_backgroundasync/">[comments]</a>

I’ve been building with FastAPI for a while now and I’m curious how people are really handling background work beyond simple demos.
 The docs show BackgroundTasks, but that feels pretty limited once things get even slightly complex.
 Some situations I keep running into:
  
sending emails, notifications, webhooks
 retrying failed tasks
 long running async jobs
 tasks that depend on other tasks
 needing visibility into what’s running or failing
  
Right now it feels like there are a few options:
  
stick with BackgroundTasks
 use something like Celery or RQ
 or just push everything into a message broker
  
But none of these feel very “FastAPI-native” or simple.
 So I’m wondering:
  
What are you using in production?
 Are you staying fully async or mixing in workers?
 How are you handling retries and failures?
 Do you have any visibility into tasks or is it just logs and hope?
  
Would be interesting to hear what actually works in real systems, not just tutorials.
    submitted by    /u/Educational-Hope960  
 [link]   [comments]

How are you actually managing background/async tasks in FastAPI in production?

<div class="md">I&#39;m learning FastAPI and trying to add a PATCH endpoint. Asked Claude about it and it told me to create a second model called `BookUpdate` where every field is Optional, separate from my main `Book` model where everything is required. Is this really how you guys do it in practice? Feels like a lot of boilerplate just for one endpoint. What&#39;s the proper way to handle partial updates in FastAPI? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/NiceSand6327"> /u/NiceSand6327 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sclp2e/trying_to_implement_patch_in_fastapi_and_claude/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sclp2e/trying_to_implement_patch_in_fastapi_and_claude/">[comments]</a>

I'm learning FastAPI and trying to add a PATCH endpoint. Asked Claude about it and it told me to create a second model called `BookUpdate` where every field is Optional, separate from my main `Book` model where everything is required.
 Is this really how you guys do it in practice? Feels like a lot of boilerplate just for one endpoint. What's the proper way to handle partial updates in FastAPI?
    submitted by    /u/NiceSand6327  
 [link]   [comments]

Trying to implement PATCH in FastAPI and Claude told me to use two separate Pydantic models — is this actually the way?

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1sevczu/i_built_a_task_visibility_layer_for_fastapis/"> <img src="https://preview.redd.it/o9o4iaovnrtg1.png?width=140&amp;height=75&amp;auto=webp&amp;s=9902ff3f5268d2ba59e9ed94836ff4960375ec37" alt="I built a task visibility layer for FastAPI's native BackgroundTasks (retries, live dashboard, logs, no broker)" title="I built a task visibility layer for FastAPI's native BackgroundTasks (retries, live dashboard, logs, no broker)" /> </a> </td><td> <div class="md">If your team uses FastAPI&#39;s <code>BackgroundTasks</code> for tasks like sending emails, webhooks, processing uploads or similar, you&#39;ve probably felt the lack of built-in observability. The bare API gives you no task IDs, no status tracking, no retries, and no persistence across restarts. When something goes wrong you&#39;re digging through app logs hoping the right line is there. Celery, ARQ, and Taskiq solve this well, but they come with a broker, separate workers, and a meaningful ops footprint. For teams whose tasks genuinely need that, those tools are the right call. <code>fastapi-taskflow</code> is for the other case: teams already using <code>BackgroundTasks</code> for simple in-process work who want retries, status tracking, and a dashboard without standing up extra infrastructure. What it adds on top of BackgroundTasks: <ul> <li>Automatic retries with configurable delay and exponential backoff per function</li> <li>Every task gets a UUID and moves through <code>PENDING &gt; RUNNING &gt; SUCCESS / FAILED</code></li> <li>A live dashboard at <code>/tasks/dashboard</code> over SSE with filtering, search, and per-task details</li> <li><code>task_log()</code> to emit timestamped log entries from inside a task, shown in the dashboard</li> <li>Full stack trace capture on failure, also in the dashboard</li> <li>SQLite persistence out of the box</li> <li>Tasks that were still pending at shutdown are re-dispatched on the next startup</li> </ul> The route signature does not change. You keep your existing <code>BackgroundTasks</code> annotation, one line at startup wires everything in: <pre><code>from fastapi import BackgroundTasks, FastAPI from fastapi_taskflow import TaskAdmin, TaskManager, task_log task_manager = TaskManager(snapshot_db=&quot;tasks.db&quot;) app = FastAPI() TaskAdmin(app, task_manager, auto_install=True) @task_manager.task(retries=3, delay=1.0, backoff=2.0) def send_email(address: str) -&gt; None: task_log(f&quot;Sending to {address}&quot;) ... @app.post(&quot;/signup&quot;) def signup(email: str, background_tasks: BackgroundTasks): task_id = background_tasks.add_task(send_email, address=email) return {&quot;task_id&quot;: task_id} </code></pre> To be clear about scope: this is not a distributed task queue and does not try to be. If you need tasks to survive across distributed services, run on dedicated workers, or integrate with a broker, reach for Celery or one of the other proper queues. This is for teams who are already happy with <code>BackgroundTasks</code> for in-process work and just want retries, visibility, and persistence without changing their setup. Available on PyPI: <code>pip install fastapi-taskflow</code> Docs and source: <a href="https://github.com/Attakay78/fastapi-taskflow">https://github.com/Attakay78/fastapi-taskflow</a> Would be good to hear from anyone using <code>BackgroundTasks</code> in production. What do you actually need to make it manageable? Retries, visibility, persistence, something else? Trying to understand what&#39;s missing for teams in this space before adding more. <a href="https://preview.redd.it/o9o4iaovnrtg1.png?width=3012&amp;format=png&amp;auto=webp&amp;s=fa729342119e970883d5eb94d390bc2432e5c025">Dashboard for tasks visibility</a> <a href="https://preview.redd.it/l9b7jjovnrtg1.png?width=3012&amp;format=png&amp;auto=webp&amp;s=a495726ebfaaa41610267ce8627e7df27c6be46b">Error visibility</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Educational-Hope960"> /u/Educational-Hope960 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sevczu/i_built_a_task_visibility_layer_for_fastapis/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sevczu/i_built_a_task_visibility_layer_for_fastapis/">[comments]</a> </td></tr></table>

If your team uses FastAPI's BackgroundTasks for tasks like sending emails, webhooks, processing uploads or similar, you've probably felt the lack of built-in observability.
 The bare API gives you no task IDs, no status tracking, no retries, and no persistence across restarts. When something goes wrong you're digging through app logs hoping the right line is there.
 Celery, ARQ, and Taskiq solve this well, but they come with a broker, separate workers, and a meaningful ops footprint. For teams whose tasks genuinely need that, those tools are the right call.
 fastapi-taskflow is for the other case: teams already using BackgroundTasks for simple in-process work who want retries, status tracking, and a dashboard without standing up extra infrastructure.
 What it adds on top of BackgroundTasks:
  
Automatic retries with configurable delay and exponential backoff per function
 Every task gets a UUID and moves through PENDING > RUNNING > SUCCESS / FAILED
 A live dashboard at /tasks/dashboard over SSE with filtering, search, and per-task details
 task_log() to emit timestamped log entries from inside a task, shown in the dashboard
 Full stack trace capture on failure, also in the dashboard
 SQLite persistence out of the box
 Tasks that were still pending at shutdown are re-dispatched on the next startup
  
The route signature does not change. You keep your existing BackgroundTasks annotation, one line at startup wires everything in:
 from fastapi import BackgroundTasks, FastAPI from fastapi_taskflow import TaskAdmin, TaskManager, task_log task_manager = TaskManager(snapshot_db="tasks.db") app = FastAPI() TaskAdmin(app, task_manager, auto_install=True) @task_manager.task(retries=3, delay=1.0, backoff=2.0) def send_email(address: str) -> None: task_log(f"Sending to {address}") ... @app.post("/signup") def signup(email: str, background_tasks: BackgroundTasks): task_id = background_tasks.add_task(send_email, address=email) return {"task_id": task_id} 
 To be clear about scope: this is not a distributed task queue and does not try to be. If you need tasks to survive across distributed services, run on dedicated workers, or integrate with a broker, reach for Celery or one of the other proper queues.
 This is for teams who are already happy with BackgroundTasks for in-process work and just want retries, visibility, and persistence without changing their setup.
 Available on PyPI: pip install fastapi-taskflow
 Docs and source: https://github.com/Attakay78/fastapi-taskflow
 Would be good to hear from anyone using BackgroundTasks in production. What do you actually need to make it manageable? Retries, visibility, persistence, something else?
 Trying to understand what's missing for teams in this space before adding more. 
 Dashboard for tasks visibility
 Error visibility
    submitted by    /u/Educational-Hope960  
 [link]   [comments]

I built a task visibility layer for FastAPI's native BackgroundTasks (retries, live dashboard, logs, no broker)

<div class="md">Learning FastAPI and not sure what the right approach is. Should I just use HTTPException directly in my endpoints or should I be creating custom exception classes with global handlers? What do you do in production? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/NiceSand6327"> /u/NiceSand6327 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1scyzzu/whats_the_best_practice_for_exception_handling_in/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1scyzzu/whats_the_best_practice_for_exception_handling_in/">[comments]</a>

Learning FastAPI and not sure what the right approach is. Should I just use HTTPException directly in my endpoints or should I be creating custom exception classes with global handlers?
 What do you do in production?
    submitted by    /u/NiceSand6327  
 [link]   [comments]

What's the best practice for exception handling in FastAPI?

<div class="md">Is there a way to have Auto Reloading of the Browser Page. It would have been nice to have auto reloading feature (of browser on .html file changes) like in vite / nextjs. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/SpiritualQuality1055"> /u/SpiritualQuality1055 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1seodgl/is_there_a_way_for_auto_reloading_web_pages_when/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1seodgl/is_there_a_way_for_auto_reloading_web_pages_when/">[comments]</a>

Is there a way to have Auto Reloading of the Browser Page. It would have been nice to have auto reloading feature (of browser on .html file changes) like in vite / nextjs.
    submitted by    /u/SpiritualQuality1055  
 [link]   [comments]

Is there a way for auto reloading web pages when working with fastapi + jinja2 templates

<div class="md">Hi everyone, I’ve been working on Dynantic, a Python ORM for DynamoDB. The project started because I wanted to use Pydantic v2 models directly as database models in my FastAPI/Lambda stack, without the need to map them to proprietary ORM types (like PynamoDB attributes) or raw Boto3 dictionaries. What My Project Does Dynantic is a synchronous-first ORM that maps Pydantic v2 models to DynamoDB tables. It handles all the complex Boto3 serialization and deserialization behind the scenes, allowing you to work with native Python types while ensuring data validation at the database level. It includes a DSL for queries, support for GSIs, and built-in handling for batch operations and transactions. Core approach: Single Table Design &amp; Polymorphism One of the main focuses of the library is how it handles multiple entities within a single table. Instead of manual parsing, it uses a discriminator pattern to automatically instantiate the correct subclass when querying the base table: Python <pre><code>from dynantic import DynamoModel, Key, Discriminator class Asset(DynamoModel): asset_id: str = Key() type: str = Discriminator() # Auto-tracks the subclass type class Meta: table_name = &quot;infrastructure&quot; @Asset.register(&quot;SERVER&quot;) class Server(Asset): cpu_cores: int memory_gb: int @Asset.register(&quot;DATABASE&quot;) class Database(Asset): engine: str # When you scan or query, you get back the actual subclasses for asset in Asset.scan(): if isinstance(asset, Server): print(f&quot;Server {asset.asset_id}: {asset.cpu_cores} cores&quot;) </code></pre> Key Technical Points: <ul> <li>Type Safety: Native support for UUIDs, Enums, Datetimes, and Sets using Pydantic’s validation engine.</li> <li>Atomic Updates: Support for ADD, SET, and REMOVE operations without fetching the item first (saving RCU).</li> <li>Production Tooling: Support for ACID Transactions, Batch operations (with auto-chunking/retries), and TTL.</li> <li>Utilities: Built-in support for Auto-UUID generation (<code>Key(auto=True)</code>) and automatic response pagination (cursor-based) for stateless APIs.</li> <li>Lambda Optimized: The library is intentionally synchronous-first to minimize cold starts and avoid the overhead of aioboto3 in serverless environments.</li> </ul> Target Audience Dynantic is designed for developers building serverless backends with AWS Lambda and FastAPI who are looking for a &quot;SQLModel-like&quot; developer experience. It’s for anyone who wants to maintain a single source of truth for their data models across their API and database layers. Comparison <ul> <li>vs PynamoDB: While PynamoDB is mature, it requires using its own attribute types. Dynantic uses pure Pydantic v2, allowing for better integration with the modern Python ecosystem.</li> <li>vs Boto3: Boto3 is extremely verbose and requires manual management of expression attributes. Dynantic provides a high-level DSL that makes complex queries much more readable and type-safe.</li> </ul> AI Integration: You can also find a Claude Code Skill in the repository that helped me better using the library with llm. Since new libraries aren&#39;t in the training data of current LLMs, this skill provides coding agents with the context of the DSL and best practices, making it easier to generate valid models and queries. The project is currently in Beta (0.3.1). I’d love to get some honest feedback on the API design or any rough edges you might find! GitHub:<a href="https://github.com/Simi24/dynantic">https://github.com/Simi24/dynantic</a> PyPI: <code>pip install dynantic</code> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Simi_auto3"> /u/Simi_auto3 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sak33o/dynantic_a_pydanticv2_orm_for_dynamodb_because_i/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sak33o/dynantic_a_pydanticv2_orm_for_dynamodb_because_i/">[comments]</a>

Hi everyone,
 I’ve been working on Dynantic, a Python ORM for DynamoDB. The project started because I wanted to use Pydantic v2 models directly as database models in my FastAPI/Lambda stack, without the need to map them to proprietary ORM types (like PynamoDB attributes) or raw Boto3 dictionaries.
 What My Project Does Dynantic is a synchronous-first ORM that maps Pydantic v2 models to DynamoDB tables. It handles all the complex Boto3 serialization and deserialization behind the scenes, allowing you to work with native Python types while ensuring data validation at the database level. It includes a DSL for queries, support for GSIs, and built-in handling for batch operations and transactions.
 Core approach: Single Table Design & Polymorphism One of the main focuses of the library is how it handles multiple entities within a single table. Instead of manual parsing, it uses a discriminator pattern to automatically instantiate the correct subclass when querying the base table:
 Python
 from dynantic import DynamoModel, Key, Discriminator class Asset(DynamoModel): asset_id: str = Key() type: str = Discriminator() # Auto-tracks the subclass type class Meta: table_name = "infrastructure" @Asset.register("SERVER") class Server(Asset): cpu_cores: int memory_gb: int @Asset.register("DATABASE") class Database(Asset): engine: str # When you scan or query, you get back the actual subclasses for asset in Asset.scan(): if isinstance(asset, Server): print(f"Server {asset.asset_id}: {asset.cpu_cores} cores") 
 Key Technical Points:
  
Type Safety: Native support for UUIDs, Enums, Datetimes, and Sets using Pydantic’s validation engine.
 Atomic Updates: Support for ADD, SET, and REMOVE operations without fetching the item first (saving RCU).
 Production Tooling: Support for ACID Transactions, Batch operations (with auto-chunking/retries), and TTL.
 Utilities: Built-in support for Auto-UUID generation (Key(auto=True)) and automatic response pagination (cursor-based) for stateless APIs.
 Lambda Optimized: The library is intentionally synchronous-first to minimize cold starts and avoid the overhead of aioboto3 in serverless environments.
  
Target Audience Dynantic is designed for developers building serverless backends with AWS Lambda and FastAPI who are looking for a "SQLModel-like" developer experience. It’s for anyone who wants to maintain a single source of truth for their data models across their API and database layers.
 Comparison
  
vs PynamoDB: While PynamoDB is mature, it requires using its own attribute types. Dynantic uses pure Pydantic v2, allowing for better integration with the modern Python ecosystem.
 vs Boto3: Boto3 is extremely verbose and requires manual management of expression attributes. Dynantic provides a high-level DSL that makes complex queries much more readable and type-safe.
  
AI Integration: You can also find a Claude Code Skill in the repository that helped me better using the library with llm. Since new libraries aren't in the training data of current LLMs, this skill provides coding agents with the context of the DSL and best practices, making it easier to generate valid models and queries.
 The project is currently in Beta (0.3.1). I’d love to get some honest feedback on the API design or any rough edges you might find!
 GitHub:https://github.com/Simi24/dynantic
 PyPI: pip install dynantic
    submitted by    /u/Simi_auto3  
 [link]   [comments]

Dynantic - A Pydantic-v2 ORM for DynamoDB (because I was tired of duplicating models)

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1sdazyz/question_on_api_design/"> <img src="https://external-preview.redd.it/ar-L0hm3RCb2R4m5JlnB-R8RrljQRMPSoT8VgE27_7Q.png?width=140&amp;height=121&amp;auto=webp&amp;s=0db40d26be5b484ef6ed334090d53eba4f1901b8" alt="Question on API Design" title="Question on API Design" /> </a> </td><td> <div class="md">Hi, I&#39;ve been working on building an API for a very simple project-management system just to teach myself the basics and I&#39;ve stumbled upon a confusing use-case. The world of the system looks like this <a href="https://preview.redd.it/rtq8kt0nzetg1.png?width=1704&amp;format=png&amp;auto=webp&amp;s=2017cfa9e4f6fec65831b98617b5c43639854194">https://preview.redd.it/rtq8kt0nzetg1.png?width=1704&amp;format=png&amp;auto=webp&amp;s=2017cfa9e4f6fec65831b98617b5c43639854194</a> <a href="https://preview.redd.it/question-on-api-design-v0-2xwr8cfzzdtg1.png?width=1704&amp;format=png&amp;auto=webp&amp;s=1cf4dfee55a2cbeae576f5a34b0b20f7fb1dbb83"></a> I&#39;ve got the following roles: <pre><code>1. ORG_MEMBER: Organization members are allowed to - Creation of projects 2. ORG_ADMIN: Organization admins are allowed to - CRUD of organization members - the C in CRUD here refers to &quot;inviting&quot; members... atop all access rights of organization members 3. PROJ_MEMBER: Project members are allowed to - CRUD of tasks - Comments on all tasks within project - View project history 4. PROJ_MANAGER: Project managers are allowed to - RUD of projects - CRUD of buckets - CRUD of project members (add organization members into project, remove project users from project) </code></pre> Since the &quot;creation of a project&quot; rests at the scope of an organization, and not at the scope of a project (because it doesn&#39;t exist yet), I&#39;m having a hard time figuring out which dependency to inject into the route. <pre><code>def get_current_user(token: HTTPAuthorizationCredentials = Depends(token_auth_scheme)): try: user_response = supabase.auth.get_user(token.credentials) supabase_user = user_response.user if not supabase_user: raise HTTPException( status_code=401, detail=&quot;Invalid token or user not found.&quot; ) auth_id = supabase_user.id user_data = supabase.table(&quot;users&quot;).select(&quot;*&quot;).eq(&quot;user_id&quot;, str(auth_id)).execute() if not user_data.data: raise HTTPException( status_code=404, detail=&quot;User not found in database.&quot; ) user_data = user_data.data[0] return User( user_id=user_data[&quot;user_id&quot;], user_name=user_data[&quot;user_name&quot;], email_id=user_data[&quot;email_id&quot;], full_name=user_data[&quot;full_name&quot;] ) except Exception as e: raise HTTPException( status_code=401, detail=f&quot;Invalid token or user not found: {e}&quot; ) def get_org_user(org_id: str, user: User = Depends(get_current_user)): res = supabase.table(&quot;org_users&quot;).select(&quot;*&quot;).eq(&quot;user_id&quot;, user.user_id).eq(&quot;org_id&quot;, org_id).single().execute() if not res.data: raise HTTPException( status_code=403, detail=&quot;User is not a member of this organization.&quot; ) return OrgUser( user_id=res.data[&quot;user_id&quot;], org_id=res.data[&quot;org_id&quot;], role=res.data[&quot;role&quot;] ) def get_proj_user(proj_id: str, user: User = Depends(get_current_user)): res = supabase.table(&quot;proj_users&quot;).select(&quot;*&quot;).eq(&quot;user_id&quot;, user.user_id).eq(&quot;proj_id&quot;, proj_id).single().execute() if not res.data: raise HTTPException( status_code=403, detail=&quot;User is not a member of this project.&quot; ) return ProjUser( user_id=res.data[&quot;user_id&quot;], proj_id=res.data[&quot;proj_id&quot;], role=res.data[&quot;role&quot;] ) </code></pre> Above are what my dependencies are... this is essentially my dependency factory <pre><code># rbac dependency factory class EntityPermissionChecker: def __init__(self, required_permission: str, entity_type: str): self.required_permission = required_permission self.entity_type = entity_type self.db = supabase def __call__(self, request: Request, user: User = Depends(get_current_user)): if self.entity_type == &quot;org&quot;: view_name = &quot;org_permissions_view&quot; id_param = &quot;org_id&quot; elif self.entity_type == &quot;project&quot;: view_name = &quot;proj_permissions_view&quot; id_param = &quot;proj_id&quot; else: raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=&quot;Invalid entity type for permission checking.&quot; ) entity_id = request.path_params.get(id_param) if not entity_id: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail=f&quot;Missing {id_param} in request path.&quot; ) response = self.db.table(view_name).select(&quot;permission_name&quot;).eq(&quot;user_id&quot;, user.user_id).eq(id_param, entity_id).eq(&quot;permission_name&quot;, self.required_permission).execute() if not response.data: raise HTTPException( status_code=status.HTTP_403_FORBIDDEN, detail=&quot;you do not have permission to perform this action.&quot; ) return True </code></pre> i&#39;ve got 3 ways to write the POST/ route for creating a project... <ol> <li>Either i inject the normal User dependency @/router.post( &quot;/&quot;, response_model=APIResponse[ProjectResponse], status_code=status.HTTP_201_CREATED ) def create_project( org_id: str, project_data: ProjectCreate, user: User= Depends(get_current_user) ): data = ProjectService().create_project(project_data, user.user_id) return { &quot;message&quot;: &quot;Project created successfully&quot;, &quot;data&quot;: data }</li> </ol> so the route would be POST: projects/ with a body : <pre><code>class ProjectCreate(BaseModel): proj_name: str org_id: str </code></pre> and here i let the ProjectService handle the verification of the user&#39;s permissions <ol> <li>or i inject an OrgUser instead @/router.post( &quot;/org/{org_id}&quot;, response_model=APIResponse[ProjectResponse], status_code=status.HTTP_201_CREATED, dependencies=[Depends(EntityPermissionChecker(&quot;create:organization&quot;, &quot;org&quot;))] ) def create_project( project_data: ProjectCreate, user: OrgUser = Depends(get_org_user) # has to depend on an OrgUser, because creating a project is at the scope of an org (proj hasn&#39;t been created yet!) ): data = ProjectService().create_project(project_data, user.user_id) return { &quot;message&quot;: &quot;Project created successfully&quot;, &quot;data&quot;: data }</li> </ol> and have the route look like POST:/projects/org/{org_id} which looks nasty, and have the body be <pre><code>class ProjectCreate(BaseModel): proj_name: str </code></pre> <ol> <li>or i just create the route within the organizations_router.py (where i have the CRUD routes for the organizations...) @/router.post( &quot;/{org_id}/project&quot;, response_model=APIResponse[ProjectResponse], status_code=status.HTTP_201_CREATED, dependencies=[Depends(EntityPermissionChecker(&quot;create:project&quot;, &quot;org&quot;))] ) def create_project_in_org( org_id: str, project_data: ProjectCreate, user: OrgUser = Depends(get_org_user) ): data = ProjectService().create_project(project_data, user.user_id) return { &quot;message&quot;: &quot;Project created successfully within organization.&quot;, &quot;data&quot;: data }</li> </ol> and the route looks like POST:/organizations/{org_id}/projects .... but then all project related routes don&#39;t fall under the projects_router.py and the POST/ one alone falls under organizations_router.py I personally think the 3rd one is best, but is there a better alternative? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/OrganizationOnly8016"> /u/OrganizationOnly8016 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sdazyz/question_on_api_design/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sdazyz/question_on_api_design/">[comments]</a> </td></tr></table>

Hi, I've been working on building an API for a very simple project-management system just to teach myself the basics and I've stumbled upon a confusing use-case.
 The world of the system looks like this
 https://preview.redd.it/rtq8kt0nzetg1.png?width=1704&format=png&auto=webp&s=2017cfa9e4f6fec65831b98617b5c43639854194
 
 I've got the following roles:
 1. ORG_MEMBER: Organization members are allowed to - Creation of projects 2. ORG_ADMIN: Organization admins are allowed to - CRUD of organization members - the C in CRUD here refers to "inviting" members... atop all access rights of organization members 3. PROJ_MEMBER: Project members are allowed to - CRUD of tasks - Comments on all tasks within project - View project history 4. PROJ_MANAGER: Project managers are allowed to - RUD of projects - CRUD of buckets - CRUD of project members (add organization members into project, remove project users from project) 
 Since the "creation of a project" rests at the scope of an organization, and not at the scope of a project (because it doesn't exist yet), I'm having a hard time figuring out which dependency to inject into the route.
 def get_current_user(token: HTTPAuthorizationCredentials = Depends(token_auth_scheme)): try: user_response = supabase.auth.get_user(token.credentials) supabase_user = user_response.user if not supabase_user: raise HTTPException( status_code=401, detail="Invalid token or user not found." ) auth_id = supabase_user.id user_data = supabase.table("users").select("*").eq("user_id", str(auth_id)).execute() if not user_data.data: raise HTTPException( status_code=404, detail="User not found in database." ) user_data = user_data.data[0] return User( user_id=user_data["user_id"], user_name=user_data["user_name"], email_id=user_data["email_id"], full_name=user_data["full_name"] ) except Exception as e: raise HTTPException( status_code=401, detail=f"Invalid token or user not found: {e}" ) def get_org_user(org_id: str, user: User = Depends(get_current_user)): res = supabase.table("org_users").select("*").eq("user_id", user.user_id).eq("org_id", org_id).single().execute() if not res.data: raise HTTPException( status_code=403, detail="User is not a member of this organization." ) return OrgUser( user_id=res.data["user_id"], org_id=res.data["org_id"], role=res.data["role"] ) def get_proj_user(proj_id: str, user: User = Depends(get_current_user)): res = supabase.table("proj_users").select("*").eq("user_id", user.user_id).eq("proj_id", proj_id).single().execute() if not res.data: raise HTTPException( status_code=403, detail="User is not a member of this project." ) return ProjUser( user_id=res.data["user_id"], proj_id=res.data["proj_id"], role=res.data["role"] ) 
 Above are what my dependencies are...
 this is essentially my dependency factory
 # rbac dependency factory class EntityPermissionChecker: def __init__(self, required_permission: str, entity_type: str): self.required_permission = required_permission self.entity_type = entity_type self.db = supabase def __call__(self, request: Request, user: User = Depends(get_current_user)): if self.entity_type == "org": view_name = "org_permissions_view" id_param = "org_id" elif self.entity_type == "project": view_name = "proj_permissions_view" id_param = "proj_id" else: raise HTTPException( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail="Invalid entity type for permission checking." ) entity_id = request.path_params.get(id_param) if not entity_id: raise HTTPException( status_code=status.HTTP_400_BAD_REQUEST, detail=f"Missing {id_param} in request path." ) response = self.db.table(view_name).select("permission_name").eq("user_id", user.user_id).eq(id_param, entity_id).eq("permission_name", self.required_permission).execute() if not response.data: raise HTTPException( status_code=status.HTTP_403_FORBIDDEN, detail="you do not have permission to perform this action." ) return True 
 i've got 3 ways to write the POST/ route for creating a project...
  
Either i inject the normal User dependency @/router.post( "/", response_model=APIResponse[ProjectResponse], status_code=status.HTTP_201_CREATED ) def create_project( org_id: str, project_data: ProjectCreate, user: User= Depends(get_current_user) ): data = ProjectService().create_project(project_data, user.user_id) return { "message": "Project created successfully", "data": data }
  
so the route would be POST: projects/ with a body :
 class ProjectCreate(BaseModel): proj_name: str org_id: str 
 and here i let the ProjectService handle the verification of the user's permissions
  
or i inject an OrgUser instead
 @/router.post( "/org/{org_id}", response_model=APIResponse[ProjectResponse], status_code=status.HTTP_201_CREATED, dependencies=[Depends(EntityPermissionChecker("create:organization", "org"))] ) def create_project( project_data: ProjectCreate, user: OrgUser = Depends(get_org_user) # has to depend on an OrgUser, because creating a project is at the scope of an org (proj hasn't been created yet!) ): data = ProjectService().create_project(project_data, user.user_id) return { "message": "Project created successfully", "data": data }
 
 and have the route look like POST:/projects/org/{org_id} which looks nasty, and have the body be
 class ProjectCreate(BaseModel): proj_name: str 
  
or i just create the route within the organizations_router.py (where i have the CRUD routes for the organizations...)
 @/router.post( "/{org_id}/project", response_model=APIResponse[ProjectResponse], status_code=status.HTTP_201_CREATED, dependencies=[Depends(EntityPermissionChecker("create:project", "org"))] ) def create_project_in_org( org_id: str, project_data: ProjectCreate, user: OrgUser = Depends(get_org_user) ): data = ProjectService().create_project(project_data, user.user_id) return { "message": "Project created successfully within organization.", "data": data }
 
 and the route looks like POST:/organizations/{org_id}/projects ....
 but then all project related routes don't fall under the projects_router.py and the POST/ one alone falls under organizations_router.py
 I personally think the 3rd one is best, but is there a better alternative?
    submitted by    /u/OrganizationOnly8016  
 [link]   [comments]

Question on API Design

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1sc5xav/how_do_you_know_if_your_fastapi_backgroundtasks/"> <img src="https://preview.redd.it/1mqh2uvzi5tg1.png?width=140&amp;height=75&amp;auto=webp&amp;s=bdffae45c47e8365af00e1776f78369dff5e55b6" alt="How do you know if your FastAPI BackgroundTasks actually ran?" title="How do you know if your FastAPI BackgroundTasks actually ran?" /> </a> </td><td> <div class="md">I asked this question here earlier about managing tasks in FastAPI and most people pointed me to Celery. Which makes sense. But for smaller applications that don’t need high throughput, distributed workers, or long-running jobs, Celery feels like overkill. Spinning up Redis or RabbitMQ just to send emails or process small background work didn’t feel right for me. So I stuck with FastAPI’s <code>BackgroundTasks</code>. The problem is… once you do: <pre><code>background_tasks.add_task(...) </code></pre> you lose visibility. <ul> <li>No task ID</li> <li>No status</li> <li>No retries</li> <li>No idea if it failed unless you check logs</li> </ul> It works, but it feels like a black box. So instead of switching to a full queue system, I built something around it: <code>fastapi-bg-taskmanager</code>. The idea is simple: keep using <code>BackgroundTasks</code>, but add the missing management layer. What it adds: <ul> <li><code>@task_manager.task(retries=3, delay=1.0, backoff=2.0)</code> to configure retry behavior per task</li> <li>Every task gets a <code>task_id</code> and moves through <code>PENDING -&gt; RUNNING -&gt; SUCCESS / FAILED</code></li> <li>Live dashboard at <code>/tasks/dashboard</code> using SSE (no polling)</li> <li>SQLite persistence so task history survives restarts</li> <li>Pending tasks that didn’t finish before shutdown get requeued on startup</li> </ul> Example: <pre><code>task_manager = TaskManager(snapshot_db=&quot;tasks.db&quot;) TaskAdmin(app, task_manager, auto_install=True) @task_manager.task(retries=3, delay=1.0, backoff=2.0) def send_email(address: str) -&gt; None: ... @app.post(&quot;/signup&quot;) def signup(email: str, background_tasks: BackgroundTasks): task_id = background_tasks.add_task(send_email, address=email) return {&quot;task_id&quot;: task_id} </code></pre> <a href="https://preview.redd.it/1mqh2uvzi5tg1.png?width=3012&amp;format=png&amp;auto=webp&amp;s=2bd3d41ea5def4bcf2bb819685254ed1c27afe4c">Sample Task Management Dashboard</a> Still early, but it’s been useful for my own app. I’m trying to validate if this is actually worth building out further: <ul> <li>Would you prefer this kind of lightweight layer for smaller projects?</li> <li>What would make this a no-brainer for you to adopt?</li> <li>What&#39;s missing and you think will be fine to add?</li> </ul> Would really appreciate honest feedback. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Educational-Hope960"> /u/Educational-Hope960 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sc5xav/how_do_you_know_if_your_fastapi_backgroundtasks/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sc5xav/how_do_you_know_if_your_fastapi_backgroundtasks/">[comments]</a> </td></tr></table>

I asked this question here earlier about managing tasks in FastAPI and most people pointed me to Celery.
 Which makes sense.
 But for smaller applications that don’t need high throughput, distributed workers, or long-running jobs, Celery feels like overkill. Spinning up Redis or RabbitMQ just to send emails or process small background work didn’t feel right for me.
 So I stuck with FastAPI’s BackgroundTasks.
 The problem is… once you do:
 background_tasks.add_task(...) 
 you lose visibility.
  
No task ID
 No status
 No retries
 No idea if it failed unless you check logs
  
It works, but it feels like a black box.
 So instead of switching to a full queue system, I built something around it: fastapi-bg-taskmanager.
 The idea is simple: keep using BackgroundTasks, but add the missing management layer.
 What it adds:
  
@task_manager.task(retries=3, delay=1.0, backoff=2.0) to configure retry behavior per task
 Every task gets a task_id and moves through PENDING -> RUNNING -> SUCCESS / FAILED
 Live dashboard at /tasks/dashboard using SSE (no polling)
 SQLite persistence so task history survives restarts
 Pending tasks that didn’t finish before shutdown get requeued on startup
  
Example:
 task_manager = TaskManager(snapshot_db="tasks.db") TaskAdmin(app, task_manager, auto_install=True) @task_manager.task(retries=3, delay=1.0, backoff=2.0) def send_email(address: str) -> None: ... @app.post("/signup") def signup(email: str, background_tasks: BackgroundTasks): task_id = background_tasks.add_task(send_email, address=email) return {"task_id": task_id} 
 Sample Task Management Dashboard
 Still early, but it’s been useful for my own app.
 I’m trying to validate if this is actually worth building out further:
  
Would you prefer this kind of lightweight layer for smaller projects?
 What would make this a no-brainer for you to adopt?
 What's missing and you think will be fine to add?
  
Would really appreciate honest feedback.
    submitted by    /u/Educational-Hope960  
 [link]   [comments]

How do you know if your FastAPI BackgroundTasks actually ran?

<div class="md">I just got the invite to FASTAPI Cloud, however after reviewing the documentation I’m still not sure who will be responsible for hosting the front-end client server that runs on localhost:3000. From the documentation, my understanding is that FASTAPI Cloud will host the python back-end server that runs the REST API, but it does not mention anything about a JavaScript client server hosting. How and where should I deploy the client server to have a production like application hosting? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/imdshizzle"> /u/imdshizzle </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sgblrm/who_will_host_the_application_client_server_with/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sgblrm/who_will_host_the_application_client_server_with/">[comments]</a>

I just got the invite to FASTAPI Cloud, however after reviewing the documentation I’m still not sure who will be responsible for hosting the front-end client server that runs on localhost:3000. From the documentation, my understanding is that FASTAPI Cloud will host the python back-end server that runs the REST API, but it does not mention anything about a JavaScript client server hosting. How and where should I deploy the client server to have a production like application hosting?
    submitted by    /u/imdshizzle  
 [link]   [comments]

Who will host the application client server with FASTAPI Cloud?

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1scc7go/i_built_a_local_transcription_server_with_fastapi/"> <img src="https://preview.redd.it/g0lc6dyrz6tg1.gif?frame=1&amp;width=140&amp;height=75&amp;auto=webp&amp;s=8b382ede9c9937491e327f8253f36177bfcfa1c6" alt="I built a local transcription server with FastAPI and Faster-Whisper - Feedbacks are welcome!" title="I built a local transcription server with FastAPI and Faster-Whisper - Feedbacks are welcome!" /> </a> </td><td> <div class="md">I’ve always wanted a way to transcribe my meetings, lectures, and voice notes without sending private audio to cloud providers like Otter or OpenAI. I couldn&#39;t find a simple &quot;all-in-one&quot; self-hosted solution that handled Speaker Identification (who said what) out of the box, so I built AmicoScript. Processing img g0lc6dyrz6tg1... It’s a FastAPI-based web app that acts as a wrapper for OpenAI&#39;s Whisper and Pyannote. Main Features: <ul> <li>🔒 Privacy First: 100% local processing. No audio ever leaves your server.</li> <li>🐳 Docker Ready: Just <code>docker compose up --build</code> and it’s running on <code>localhost:8002</code>.</li> <li>👥 Speaker Diarization: Uses Pyannote to label &quot;Speaker 0&quot;, &quot;Speaker 1&quot;, etc. (Optional, requires a HuggingFace token).</li> <li>🚀 Performance: Supports models from <code>tiny</code> to <code>large-v3</code>. Background tasking ensures the UI doesn&#39;t freeze during long files.</li> <li>📄 Export Formats: Download results in TXT, SRT (for video subtitles), Markdown, or JSON.</li> <li>💾 Low Footprint: Temporary files are automatically cleaned up after 1 hour.</li> </ul> Tech Stack: <ul> <li>Backend: Python 3.10+, FastAPI.</li> <li>Frontend: Vanilla JS/HTML/CSS (Single-page app served by the backend, no complex build steps).</li> <li>Engine: Faster-Whisper &amp; Pyannote-audio.</li> </ul> I’m still refining the UI and would love some feedback from this community on how it runs on your home labs (NUCs, NAS, etc.). GitHub:<a href="https://github.com/sim186/AmicoScript">https://github.com/sim186/AmicoScript</a> A note on AI: I used LLMs to help accelerate the boilerplate and integration code, but I&#39;ve personally tested and debugged the threading and Docker logic to ensure it&#39;s stable for self-hosting. Happy to answer any questions about the setup! <a href="https://i.redd.it/g0lc6dyrz6tg1.gif">https://i.redd.it/g0lc6dyrz6tg1.gif</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/seamoce"> /u/seamoce </a> <a href="https://www.reddit.com/r/FastAPI/comments/1scc7go/i_built_a_local_transcription_server_with_fastapi/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1scc7go/i_built_a_local_transcription_server_with_fastapi/">[comments]</a> </td></tr></table>

I’ve always wanted a way to transcribe my meetings, lectures, and voice notes without sending private audio to cloud providers like Otter or OpenAI. I couldn't find a simple "all-in-one" self-hosted solution that handled Speaker Identification (who said what) out of the box, so I built AmicoScript.
 Processing img g0lc6dyrz6tg1...
 It’s a FastAPI-based web app that acts as a wrapper for OpenAI's Whisper and Pyannote.
 Main Features:
  
🔒 Privacy First: 100% local processing. No audio ever leaves your server.
 🐳 Docker Ready: Just docker compose up --build and it’s running on localhost:8002.
 👥 Speaker Diarization: Uses Pyannote to label "Speaker 0", "Speaker 1", etc. (Optional, requires a HuggingFace token).
 🚀 Performance: Supports models from tiny to large-v3. Background tasking ensures the UI doesn't freeze during long files.
 📄 Export Formats: Download results in TXT, SRT (for video subtitles), Markdown, or JSON.
 💾 Low Footprint: Temporary files are automatically cleaned up after 1 hour.
  
Tech Stack:
  
Backend: Python 3.10+, FastAPI.
 Frontend: Vanilla JS/HTML/CSS (Single-page app served by the backend, no complex build steps).
 Engine: Faster-Whisper & Pyannote-audio.
  
I’m still refining the UI and would love some feedback from this community on how it runs on your home labs (NUCs, NAS, etc.).
 GitHub:https://github.com/sim186/AmicoScript
 A note on AI: I used LLMs to help accelerate the boilerplate and integration code, but I've personally tested and debugged the threading and Docker logic to ensure it's stable for self-hosting.
 Happy to answer any questions about the setup!
 https://i.redd.it/g0lc6dyrz6tg1.gif
    submitted by    /u/seamoce  
 [link]   [comments]

I built a local transcription server with FastAPI and Faster-Whisper - Feedbacks are welcome!

<div class="md">Hi everyone, Since the last post I made for my module <code>fastapi-toolsets</code>, 2 major versions have passed and a lot of features have been added! I&#39;ve been busy improving the Crud module with fixes and new features: <ul> <li><code>OffsetPagination</code> and <code>CursorPagination</code> </li> <li>Unified Paginated (both offset and cursor pagination on the same endpoint) </li> <li>Faceted search, Sorting and Column search</li> </ul> I&#39;ve posted an article to demonstrate these new capabilities through a concrete example with offset and cursor pagination, full-text search, facet filtering, and client-driven sorting. Here&#39;s a quick overview of what it looks like: The core idea is a `CrudFactory` that acts as a single source of truth for what your API exposes: <code>python ArticleCrud = CrudFactory( model=Article, cursor_column=Article.created_at, searchable_fields=[Article.title, Article.body, (Article.category, Category.name)], facet_fields=[Article.status, (Article.category, Category.name)], order_fields=[Article.title, Article.created_at], ) </code> Routes then become thin wrappers, all query parameters (page, cursor, filters, search, ordering) are automatically handled by <code>paginate_params()</code>: <code>python @router.get(&quot;/articles&quot;) async def list_articles(session: SessionDep, params: Annotated[dict, Depends(ArticleCrud.paginate_params())]) -&gt; PaginatedResponse[ArticleRead]: return await ArticleCrud.paginate(session, **params, schema=ArticleRead) </code> This gives you offset and cursor pagination, search, filters, and sorting out of the box — with a single endpoint supporting both pagination strategies via a `pagination_type` query param. <h1>Links</h1> <ul> <li>Article: <a href="https://blog.d3vyce.fr/posts/how-to-implement-pagination-sorting-and-filtering-with-fastapi/">https://blog.d3vyce.fr/posts/how-to-implement-pagination-sorting-and-filtering-with-fastapi/</a></li> <li>GitHub: <a href="https://github.com/d3vyce/fastapi-toolsets">https://github.com/d3vyce/fastapi-toolsets</a></li> <li>Docs: <a href="https://fastapi-toolsets.d3vyce.fr">https://fastapi-toolsets.d3vyce.fr</a></li> <li>PyPI: <code>uv add fastapi-toolsets</code></li> </ul> Feedback welcome! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/d3vyce"> /u/d3vyce </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sgjrhd/how_to_implement_paginationsorting_and_filtering/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sgjrhd/how_to_implement_paginationsorting_and_filtering/">[comments]</a>

Hi everyone,
 Since the last post I made for my module fastapi-toolsets, 2 major versions have passed and a lot of features have been added!
 I've been busy improving the Crud module with fixes and new features:
  
OffsetPagination and CursorPagination
 
Unified Paginated (both offset and cursor pagination on the same endpoint)
 
Faceted search, Sorting and Column search
  
I've posted an article to demonstrate these new capabilities through a concrete example with offset and cursor pagination, full-text search, facet filtering, and client-driven sorting. Here's a quick overview of what it looks like:
 The core idea is a `CrudFactory` that acts as a single source of truth for what your API exposes:
 python ArticleCrud = CrudFactory( model=Article, cursor_column=Article.created_at, searchable_fields=[Article.title, Article.body, (Article.category, Category.name)], facet_fields=[Article.status, (Article.category, Category.name)], order_fields=[Article.title, Article.created_at], ) 
 Routes then become thin wrappers, all query parameters (page, cursor, filters, search, ordering) are automatically handled by paginate_params():
 python @router.get("/articles") async def list_articles(session: SessionDep, params: Annotated[dict, Depends(ArticleCrud.paginate_params())]) -> PaginatedResponse[ArticleRead]: return await ArticleCrud.paginate(session, **params, schema=ArticleRead) 
 This gives you offset and cursor pagination, search, filters, and sorting out of the box — with a single endpoint supporting both pagination strategies via a `pagination_type` query param.
 Links
  
Article: https://blog.d3vyce.fr/posts/how-to-implement-pagination-sorting-and-filtering-with-fastapi/
 
GitHub: https://github.com/d3vyce/fastapi-toolsets
 
Docs: https://fastapi-toolsets.d3vyce.fr
 
PyPI: uv add fastapi-toolsets
 
 Feedback welcome!
    submitted by    /u/d3vyce  
 [link]   [comments]

How to implement pagination,sorting and filtering with fastapi? FastAPI-Toolsets v3.0

<div class="md">Working on a scraping API built with FastAPI where clients submit batch jobs (up to 100 URLs) and need to receive results as they complete rather than waiting for the full batch. Currently using Server-Sent Events with StreamingResponse. The basic implementation works but running into some issues. Background task management: using asyncio tasks to run scrapers concurrently, but managing cancellation when clients disconnect is messy. Connection handling: if the client reconnects after a disconnect, they miss results that came through while disconnected. Thinking about buffering results in Redis with a job ID, but not sure how long to keep them. Error handling: individual URL failures shouldn&#39;t kill the stream. Currently wrapping each task in try/except and streaming error events, but the error format feels inconsistent. Progress tracking: clients want to know how many URLs are done vs pending vs failed. Sending a summary event every N completions works but feels hacky. Anyone built something similar with FastAPI SSE? Looking for patterns that work well in production, particularly around reconnection handling and clean shutdown. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/SharpRule4025"> /u/SharpRule4025 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sc1tpk/streaming_scraping_job_results_with_fastapi_sse/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sc1tpk/streaming_scraping_job_results_with_fastapi_sse/">[comments]</a>

Working on a scraping API built with FastAPI where clients submit batch jobs (up to 100 URLs) and need to receive results as they complete rather than waiting for the full batch.
 Currently using Server-Sent Events with StreamingResponse. The basic implementation works but running into some issues.
 Background task management: using asyncio tasks to run scrapers concurrently, but managing cancellation when clients disconnect is messy.
 Connection handling: if the client reconnects after a disconnect, they miss results that came through while disconnected. Thinking about buffering results in Redis with a job ID, but not sure how long to keep them.
 Error handling: individual URL failures shouldn't kill the stream. Currently wrapping each task in try/except and streaming error events, but the error format feels inconsistent.
 Progress tracking: clients want to know how many URLs are done vs pending vs failed. Sending a summary event every N completions works but feels hacky.
 Anyone built something similar with FastAPI SSE? Looking for patterns that work well in production, particularly around reconnection handling and clean shutdown.
    submitted by    /u/SharpRule4025  
 [link]   [comments]

Streaming scraping job results with FastAPI SSE: what's the cleanest pattern?

&#32; submitted by &#32; <a href="https://www.reddit.com/user/CustardGirl43"> /u/CustardGirl43 </a> <a href="/r/NewsAPI/comments/1se122b/gathering_sources_more_than_a_month_out/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1se1342/gathering_sources_more_than_a_month_out/">[comments]</a>

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

Gathering sources more than a month out

<div class="md">I&#39;ve been working on <code>fastapi-views</code>, a library that brings Django REST Framework-style class-based views to FastAPI while keeping full type safety and dependency injection. The core idea: instead of wiring up individual route functions, you inherit from a view class and the library registers routes, status codes, and OpenAPI docs automatically — with correct HTTP semantics out of the box. It also ships with DRF-style filters, RFC 9457 Problem Details for error responses (with ready-to-use exception classes), and optional Prometheus metrics and OpenTelemetry tracing. It&#39;s not supposed to be a &quot;batteries-included&quot; / &quot;all-in-one&quot; framework like DRF — the package is not tied to any specific database/ORM, auth framework, or pattern. That said, I&#39;m considering implementing an auth layer and permission classes, as well as some optional SQLAlchemy integration. - Docs: <a href="https://asynq-io.github.io/fastapi-views/">https://asynq-io.github.io/fastapi-views/</a> - Source: <a href="https://github.com/asynq-io/fastapi-views">https://github.com/asynq-io/fastapi-views</a> - Install: `pip install fastapi-views` I&#39;ve been using it with success for a while now, so I thought I&#39;d share it here. If you&#39;ve been building APIs with FastAPI and found yourself copy-pasting the same patterns across projects, this might be worth a look. Happy to hear what features you&#39;d find most valuable, what&#39;s missing, or your thoughts on the project in general. If you like it, leaving a star would be appreciated. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/SatisfactionScary663"> /u/SatisfactionScary663 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sc2xdo/fastapi_views_yet_another_class_based_views/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sc2xdo/fastapi_views_yet_another_class_based_views/">[comments]</a>

I've been working on fastapi-views, a library that brings Django REST Framework-style class-based views to FastAPI while keeping full type safety and dependency injection.
 The core idea: instead of wiring up individual route functions, you inherit from a view class and the library registers routes, status codes, and OpenAPI docs automatically — with correct HTTP semantics out of the box.
 It also ships with DRF-style filters, RFC 9457 Problem Details for error responses (with ready-to-use exception classes), and optional Prometheus metrics and OpenTelemetry tracing.
 It's not supposed to be a "batteries-included" / "all-in-one" framework like DRF — the package is not tied to any specific database/ORM, auth framework, or pattern. That said, I'm considering implementing an auth layer and permission classes, as well as some optional SQLAlchemy integration.
 - Docs: https://asynq-io.github.io/fastapi-views/
 - Source: https://github.com/asynq-io/fastapi-views
 - Install: `pip install fastapi-views`
 I've been using it with success for a while now, so I thought I'd share it here. If you've been building APIs with FastAPI and found yourself copy-pasting the same patterns across projects, this might be worth a look. Happy to hear what features you'd find most valuable, what's missing, or your thoughts on the project in general. If you like it, leaving a star would be appreciated.
    submitted by    /u/SatisfactionScary663  
 [link]   [comments]

FastAPI Views - yet another class based views library

<div class="md">Building a RAG-based appliance manual assistant. Works perfectly on localhost, breaks in production on Railway. Stack: FastAPI, Pinecone, SentenceTransformer, Groq, Cloudinary, MongoDB. Frontend on Vercel, backend + ml_service both on Railway as separate services. The full failure chain I traced: <ul> <li>Cloudinary env vars incomplete (only URL set, no API key/secret) → manual PDFs never uploaded</li> <li>No upload → no QR generated → nothing sent to ML service</li> <li>ML service never indexed anything into Pinecone</li> <li>RAG queries return empty every time</li> </ul> Cloudinary is fixed now. Still have these open questions: Problem 1 — 502 on upload processing ML service was loading SentenceTransformer synchronously on the request thread, Railway proxy was timing out. Fixed by moving to a global singleton + asyncio.to_thread inside BackgroundTasks. Is this the right pattern for heavy CPU tasks in FastAPI prod or is there a better approach? Problem 2 — Background task failures are silent If Pinecone is unreachable or OOM happens inside a BackgroundTask, MongoDB status stays &quot;processing&quot; forever. Currently wrapping everything in try/except and updating to &quot;failed&quot;. Is there a better observability pattern here — some kind of task result tracking without bringing in Celery? Problem 3 — Pinecone index object not JSON serializable Debug route was returning the Pinecone index object directly, got this: <pre><code>TypeError(&quot;&#39;_thread.RLock&#39; object is not iterable&quot;) </code></pre> Fixed by returning <code>index.describe_index_stats().to_dict()</code> instead. Posting in case it saves someone else time. Main question: Is eager-loading SentenceTransformer in a FastAPI startup event via <code>asyncio.to_thread</code> the right call on Railway to avoid cold start 502s? Any memory gotchas on the 512MB starter plan when OCR + embeddings are running simultaneously? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Legitimate_Scene226"> /u/Legitimate_Scene226 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sbdcxn/fastapi_ml_service_on_railway_backgroundtasks/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sbdcxn/fastapi_ml_service_on_railway_backgroundtasks/">[comments]</a>

Building a RAG-based appliance manual assistant. Works perfectly on localhost, breaks in production on Railway.
 Stack: FastAPI, Pinecone, SentenceTransformer, Groq, Cloudinary, MongoDB. Frontend on Vercel, backend + ml_service both on Railway as separate services.
 The full failure chain I traced:
  
Cloudinary env vars incomplete (only URL set, no API key/secret) → manual PDFs never uploaded
 No upload → no QR generated → nothing sent to ML service
 ML service never indexed anything into Pinecone
 RAG queries return empty every time
  
Cloudinary is fixed now. Still have these open questions:
 Problem 1 — 502 on upload processing ML service was loading SentenceTransformer synchronously on the request thread, Railway proxy was timing out. Fixed by moving to a global singleton + asyncio.to_thread inside BackgroundTasks. Is this the right pattern for heavy CPU tasks in FastAPI prod or is there a better approach?
 Problem 2 — Background task failures are silent If Pinecone is unreachable or OOM happens inside a BackgroundTask, MongoDB status stays "processing" forever. Currently wrapping everything in try/except and updating to "failed". Is there a better observability pattern here — some kind of task result tracking without bringing in Celery?
 Problem 3 — Pinecone index object not JSON serializable Debug route was returning the Pinecone index object directly, got this:
 TypeError("'_thread.RLock' object is not iterable") 
 Fixed by returning index.describe_index_stats().to_dict() instead. Posting in case it saves someone else time.
 Main question: Is eager-loading SentenceTransformer in a FastAPI startup event via asyncio.to_thread the right call on Railway to avoid cold start 502s? Any memory gotchas on the 512MB starter plan when OCR + embeddings are running simultaneously?
    submitted by    /u/Legitimate_Scene226  
 [link]   [comments]

FastAPI ML Service on Railway — BackgroundTasks + SentenceTransformer 502, Pinecone never getting indexed

<div class="md">Every time I start a new project, I spend 3 hours setting up the same Docker configs, JWT auth, and CI/CD pipelines. I built Projx to fix this. It’s a CLI that scaffolds &#39;production-grade&#39; stacks (FastAPI/Fastify + React + Infra). The cool part: I just added MCP (Model Context Protocol) support. If you use Claude Code or Cursor, you can just tell the agent: &#39;Use Projx to build a SaaS MVP with FastAPI&#39; and it calls the CLI to generate the whole tested structure in seconds instead of the AI hallucinating 50 files. Just hit 1.5k downloads on npm in 48 hours (mostly bots, probably lol), but I&#39;m looking for a few real humans to break it and tell me what’s missing. Repo: <a href="https://github.com/ukanhaupa/projx"><code>https://github.com/ukanhaupa/projx</code></a> Install: <code>npx create-projx</code> Curios to hear if this actually saves you time or if I&#39;m just over-engineering my own life. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Previous_Cod_4446"> /u/Previous_Cod_4446 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1se69c7/i_got_tired_of_manual_boilerplate_so_i_built_a/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1se69c7/i_got_tired_of_manual_boilerplate_so_i_built_a/">[comments]</a>

Every time I start a new project, I spend 3 hours setting up the same Docker configs, JWT auth, and CI/CD pipelines.
 I built Projx to fix this. It’s a CLI that scaffolds 'production-grade' stacks (FastAPI/Fastify + React + Infra).
 The cool part: I just added MCP (Model Context Protocol) support. If you use Claude Code or Cursor, you can just tell the agent: 'Use Projx to build a SaaS MVP with FastAPI' and it calls the CLI to generate the whole tested structure in seconds instead of the AI hallucinating 50 files.
 Just hit 1.5k downloads on npm in 48 hours (mostly bots, probably lol), but I'm looking for a few real humans to break it and tell me what’s missing.
 Repo: https://github.com/ukanhaupa/projx Install: npx create-projx
 Curios to hear if this actually saves you time or if I'm just over-engineering my own life.
    submitted by    /u/Previous_Cod_4446  
 [link]   [comments]

I got tired of manual boilerplate, so I built a CLI that let AI agents scaffold production apps for me.

<div class="md">I am seeing these kind of jobs everywhere in my linkedin. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Kraven_Holmes"> /u/Kraven_Holmes </a> <a href="https://i.redd.it/crggertdqbtg1.jpeg">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1scxbzg/they_want_a_data_scientist_backend_dev_ml/">[comments]</a>

I am seeing these kind of jobs everywhere in my linkedin.
    submitted by    /u/Kraven_Holmes  
 [link]   [comments]

They want a data scientist + backend dev + ML engineer + DevOps person in one fresh graduate. 💀

<div class="md">So in my past webapp that I built which was a forum type app I used Flask in python for backend but I decided to try and learn Django and it is incredibly easier. I mean it handles all of the auth and database management while also giving access to an admin dashboard. I feel like it leaves almost no room for javascript but I am also a fairly rookie coder and rely a lot on AI so please correct me if I am wrong. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/VirtualParsnip3789"> /u/VirtualParsnip3789 </a> <a href="https://www.reddit.com/r/django/comments/1sgbg3q/just_started_using_django_feels_too_good_to_be/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sgbg3q/just_started_using_django_feels_too_good_to_be/">[comments]</a>

So in my past webapp that I built which was a forum type app I used Flask in python for backend but I decided to try and learn Django and it is incredibly easier. I mean it handles all of the auth and database management while also giving access to an admin dashboard. I feel like it leaves almost no room for javascript but I am also a fairly rookie coder and rely a lot on AI so please correct me if I am wrong. 
    submitted by    /u/VirtualParsnip3789  
 [link]   [comments]

Just started using django, feels too good to be true.

&#32; submitted by &#32; <a href="https://www.reddit.com/user/dwaxe"> /u/dwaxe </a> <a href="https://www.djangoproject.com/weblog/2026/apr/07/security-releases/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sexeqa/django_security_releases_issued_604_5213_and_4230/">[comments]</a>

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

Django security releases issued: 6.0.4, 5.2.13, and 4.2.30

<div class="md">This article explains how to implement real-time table filtering and data exporting in Django using <code>django-tables2</code> and HTMX, eliminating the need for custom JavaScript. By utilizing HTMX to partially update the page based on input changes, the approach achieves a fast user experience while keeping logic in the backend. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/fundor333"> /u/fundor333 </a> <a href="https://fundor333.com/post/2026/django-table-filter-export-with-htmx/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sbggko/django_table_filter_and_export_with_htmx/">[comments]</a>

This article explains how to implement real-time table filtering and data exporting in Django using django-tables2 and HTMX, eliminating the need for custom JavaScript. By utilizing HTMX to partially update the page based on input changes, the approach achieves a fast user experience while keeping logic in the backend.
    submitted by    /u/fundor333  
 [link]   [comments]

Django Table, Filter and Export With Htmx

<div class="md">I’ve been working on a Django project to better understand knowledge graphs, LLM explainability, and document processing. The app lets you upload a document, process it asynchronously, build a graph from the extracted entities/relations, and then ask natural-language questions against that graph. Stack is mostly: <ul> <li>Django</li> <li>HTMX</li> <li>Celery + Redis</li> <li>Memgraph</li> <li>Cytoscape.js</li> <li>OpenAI / Ollama</li> </ul> A lot of the work ended up not being just “call an LLM and get an answer”, but all the messy parts around it: <ul> <li>chunking strategy</li> <li>coreference for relation extraction</li> <li>alias / duplicate entity merging</li> <li>graph quality issues like isolated nodes and fragmented components</li> <li>making the answers explainable instead of just plausible</li> </ul> So the QA side now shows: <ul> <li>the generated Cypher</li> <li>raw query rows</li> <li>provenance/source snippets</li> <li>question-analysis metadata</li> <li>graph highlighting for the relevant nodes/edges</li> </ul> I also added saved QA sessions per document, graph reloads on the QA page, processing logs, and a Docker setup so the whole thing is easier to run. This was mainly a learning project, but I wanted to build it in a way that still felt structured and extensible instead of just a quick prototype. GitHub: <a href="https://github.com/helios51193/knowledge-graph-qa">https://github.com/helios51193/knowledge-graph-qa</a> Would genuinely love feedback from Django folks, especially on the architecture / UX side. EDIT : Added type-hints and doc-strings. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/big_haptun777"> /u/big_haptun777 </a> <a href="https://www.reddit.com/r/django/comments/1sce3gn/built_a_django_app_that_turns_documents_into_a/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sce3gn/built_a_django_app_that_turns_documents_into_a/">[comments]</a>

I’ve been working on a Django project to better understand knowledge graphs, LLM explainability, and document processing.
 The app lets you upload a document, process it asynchronously, build a graph from the extracted entities/relations, and then ask natural-language questions against that graph.
 Stack is mostly:
  
Django
 HTMX
 Celery + Redis
 Memgraph
 Cytoscape.js
 OpenAI / Ollama
  
A lot of the work ended up not being just “call an LLM and get an answer”, but all the messy parts around it:
  
chunking strategy
 coreference for relation extraction
 alias / duplicate entity merging
 graph quality issues like isolated nodes and fragmented components
 making the answers explainable instead of just plausible
  
So the QA side now shows:
  
the generated Cypher
 raw query rows
 provenance/source snippets
 question-analysis metadata
 graph highlighting for the relevant nodes/edges
  
I also added saved QA sessions per document, graph reloads on the QA page, processing logs, and a Docker setup so the whole thing is easier to run.
 This was mainly a learning project, but I wanted to build it in a way that still felt structured and extensible instead of just a quick prototype.
 GitHub: https://github.com/helios51193/knowledge-graph-qa
 Would genuinely love feedback from Django folks, especially on the architecture / UX side.
 EDIT : Added type-hints and doc-strings.
    submitted by    /u/big_haptun777  
 [link]   [comments]

Built a Django app that turns documents into a knowledge graph and lets you query it

<div class="md">Hi everyone, I&#39;m a beginner in backend development, currently focusing on Django. I haven&#39;t landed my first job or done any professional work yet; my foundation is mostly built on online courses. Here is my biggest struggle right now: I often watch project tutorials on YouTube, and I completely understand the logic and what&#39;s going on. But the moment I try to start building a project on my own from scratch, my mind goes blank and I just get stuck. On top of that, I constantly find myself running into large, complex concepts (like architecture design, deployment, etc.) that feel overwhelming. How can I effectively break out of this &quot;tutorial hell&quot; and start building independently? How do I bridge the gap between just understanding a video and actually writing the code myself? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Om_JR"> /u/Om_JR </a> <a href="https://www.reddit.com/r/django/comments/1sdp3q0/beginner_in_djangobackend_i_understand_tutorials/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sdp3q0/beginner_in_djangobackend_i_understand_tutorials/">[comments]</a>

Hi everyone,
 I'm a beginner in backend development, currently focusing on Django. I haven't landed my first job or done any professional work yet; my foundation is mostly built on online courses.
 Here is my biggest struggle right now: I often watch project tutorials on YouTube, and I completely understand the logic and what's going on. But the moment I try to start building a project on my own from scratch, my mind goes blank and I just get stuck.
 On top of that, I constantly find myself running into large, complex concepts (like architecture design, deployment, etc.) that feel overwhelming.
 How can I effectively break out of this "tutorial hell" and start building independently? How do I bridge the gap between just understanding a video and actually writing the code myself?
    submitted by    /u/Om_JR  
 [link]   [comments]

Beginner in Django/Backend: I understand tutorials but freeze when building on my own. How do I improve?

<div class="md">&quot;How do you debug N+1 queries in your Django views? Do you use debug-toolbar, just read logs, or something else?&quot; </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Organic_Release1028"> /u/Organic_Release1028 </a> <a href="https://www.reddit.com/r/django/comments/1sfnm5h/how_do_you_debug_n1_queries_in_your_django_views/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sfnm5h/how_do_you_debug_n1_queries_in_your_django_views/">[comments]</a>

"How do you debug N+1 queries in your Django views? Do you use debug-toolbar, just read logs, or something else?"
    submitted by    /u/Organic_Release1028  
 [link]   [comments]

How do you debug N+1 queries in your Django views?

<div class="md">Hello everyone 👋, A couple months ago I shared an early version of Cratos here. Got 24 stars and more useful feedback than I expected. People pointed out real gaps in the security model, the install experience was painful, and the UI was rough. This post is a follow-up to say thanks and show what came out of that feedback. For newcomers: Cratos is a self-hosted scheduling backend. Your app calls an API to register a job (a URL, a schedule, and a payload), and Cratos executes it at the right time by sending a webhook, with retries and execution history. No code runs inside Cratos, your business logic stays in your own services. I built it because I kept solving the same problem across projects: scheduling HTTP calls per user or per event, and there wasn’t a clean self-hosted solution focused specifically on that. What changed since the last version - UI : This was the biggest piece of feedback. The interface was fully rewritten with a cleaner layout. It now includes a dedicated task detail page with full execution history, exact timestamps, and per-run error inspection. - Server / Installation : Consolidated from multiple repos into one. Install is now two commands using Docker images on Docker Hub, no building from source. Execution history is more complete too: HTTP status, response body, duration, and error details per run. - Security : Two things that were flagged last time and rightfully so. Webhook signing with HMAC-SHA256 so your endpoints can verify every request came from Cratos. Origin allowlisting so callback URLs must be explicitly approved before Cratos will call them, enforced at request time to prevent SSRF. GitHub: <a href="https://github.com/Ghiles1010/Cratos">https://github.com/Ghiles1010/Cratos</a> I’m still very open to feedback 🙏, especially from anyone who tried v1 and ran into issues. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/One-Meeting-921"> /u/One-Meeting-921 </a> <a href="https://www.reddit.com/gallery/1sd81pn">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sd81pn/i_rebuilt_my_selfhosted_webhook_scheduler_cratos/">[comments]</a>

Hello everyone 👋,
 A couple months ago I shared an early version of Cratos here. Got 24 stars and more useful feedback than I expected. People pointed out real gaps in the security model, the install experience was painful, and the UI was rough. This post is a follow-up to say thanks and show what came out of that feedback.
 For newcomers: Cratos is a self-hosted scheduling backend. Your app calls an API to register a job (a URL, a schedule, and a payload), and Cratos executes it at the right time by sending a webhook, with retries and execution history. No code runs inside Cratos, your business logic stays in your own services. I built it because I kept solving the same problem across projects: scheduling HTTP calls per user or per event, and there wasn’t a clean self-hosted solution focused specifically on that.
 What changed since the last version
 - UI : This was the biggest piece of feedback. The interface was fully rewritten with a cleaner layout. It now includes a dedicated task detail page with full execution history, exact timestamps, and per-run error inspection.
 - Server / Installation : Consolidated from multiple repos into one. Install is now two commands using Docker images on Docker Hub, no building from source. Execution history is more complete too: HTTP status, response body, duration, and error details per run.
 - Security : Two things that were flagged last time and rightfully so. Webhook signing with HMAC-SHA256 so your endpoints can verify every request came from Cratos. Origin allowlisting so callback URLs must be explicitly approved before Cratos will call them, enforced at request time to prevent SSRF.
 GitHub: https://github.com/Ghiles1010/Cratos 
 I’m still very open to feedback 🙏, especially from anyone who tried v1 and ran into issues.
    submitted by    /u/One-Meeting-921  
 [link]   [comments]

I rebuilt my self-hosted webhook scheduler (Cratos) after your feedback

<div class="md">I have been going back and forth for the last few weeks after my 8-5 shift trying to plan for a Multi-tenant SaaS I have a lot of questions, and I can&#39;t really be satisfied about any answers I would reach, I read articles, discussed with AIs, but I need advices based on real experience, if you can help <ol> <li>Is djang-tenants the way to go for that?</li> <li>Auth .. i would def use django auth instead of re-inventing the wheel, so should auth occurs on the tenant level or public leve? auth_users table would exist in every tenant schema?</li> <li>VIP Customers ... I was thinking about giving vip customers dedicated databases if they want to, and include the db connection in the public layer tenants table, then have a simple router to route the requests to this db when needed, what do you think of that approach?</li> </ol> I am sorry I am just lost and overwhelmed, if you have resources I am really open to read them </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/_khi4"> /u/_khi4 </a> <a href="https://www.reddit.com/r/django/comments/1sd643b/multitenant_saas_with_django/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sd643b/multitenant_saas_with_django/">[comments]</a>

I have been going back and forth for the last few weeks after my 8-5 shift trying to plan for a Multi-tenant SaaS
 I have a lot of questions, and I can't really be satisfied about any answers I would reach, I read articles, discussed with AIs, but I need advices based on real experience, if you can help
  
Is djang-tenants the way to go for that?
 
Auth .. i would def use django auth instead of re-inventing the wheel, so should auth occurs on the tenant level or public leve? auth_users table would exist in every tenant schema?
 
VIP Customers ... I was thinking about giving vip customers dedicated databases if they want to, and include the db connection in the public layer tenants table, then have a simple router to route the requests to this db when needed, what do you think of that approach?
 
 I am sorry I am just lost and overwhelmed, if you have resources I am really open to read them
    submitted by    /u/_khi4  
 [link]   [comments]

Multi-tenant SaaS with django

<div class="md">Been using <code>django-silk</code> for a while. The profiling is great but I kept hitting the same UI papercuts: single-value filter dropdowns, a drawer that eats half your screen, no real pagination. Built a fork called <code>django-silky</code>. The part I&#39;m most happy with is N+1 detection. Silk already captures every SQL query so I added a fingerprinting pass per request. If the same structural query fires 3+ times you get an orange banner on the SQL tab showing the pattern, count badge, total ms cost, and the offending rows highlighted in the table. There&#39;s a filter toggle to show only N+1 requests across the board. <a href="https://preview.redd.it/p8zufpkf2ltg1.png?width=3022&amp;format=png&amp;auto=webp&amp;s=b93a5e6889ef283f1cccb8c9c7a9326045e9da3e">https://preview.redd.it/p8zufpkf2ltg1.png?width=3022&amp;format=png&amp;auto=webp&amp;s=b93a5e6889ef283f1cccb8c9c7a9326045e9da3e</a> <a href="https://preview.redd.it/zmo4ma4h2ltg1.png?width=3022&amp;format=png&amp;auto=webp&amp;s=5826ddf7292b4051e53143e6cb63c3828ad64a01">https://preview.redd.it/zmo4ma4h2ltg1.png?width=3022&amp;format=png&amp;auto=webp&amp;s=5826ddf7292b4051e53143e6cb63c3828ad64a01</a> Also rebuilt the analytics dashboard with a request activity timeline, status code donut, HTTP method lollipop, response time histogram, and latency percentile curves for both request time and SQL time. <a href="https://preview.redd.it/hyv2tasj2ltg1.png?width=3022&amp;format=png&amp;auto=webp&amp;s=17f3ae71d9718ef123ccc31add869f0b6f0cf49a">https://preview.redd.it/hyv2tasj2ltg1.png?width=3022&amp;format=png&amp;auto=webp&amp;s=17f3ae71d9718ef123ccc31add869f0b6f0cf49a</a> Same schema as upstream so it&#39;s just: <code>pip uninstall django-silk &amp;&amp; pip install django-silky</code> <a href="http://github.com/VaishnavGhenge/django-silky">github.com/VaishnavGhenge/django-silky</a> UPDATE: I updated package with new user selectable color schemes and also improved color contrast issues. <a href="https://preview.redd.it/t7vu84wzrstg1.png?width=3022&amp;format=png&amp;auto=webp&amp;s=9a724e77cc42c07c61f25baa856cda103c3e834c">https://preview.redd.it/t7vu84wzrstg1.png?width=3022&amp;format=png&amp;auto=webp&amp;s=9a724e77cc42c07c61f25baa856cda103c3e834c</a> <a href="https://preview.redd.it/mf22ngy2sstg1.png?width=3022&amp;format=png&amp;auto=webp&amp;s=0443a502315583e30d0567e3d6a924dfe2a36794">https://preview.redd.it/mf22ngy2sstg1.png?width=3022&amp;format=png&amp;auto=webp&amp;s=0443a502315583e30d0567e3d6a924dfe2a36794</a> <a href="https://preview.redd.it/0ydzf4s4sstg1.png?width=3022&amp;format=png&amp;auto=webp&amp;s=926a41783d8dcabc5350d5ef82f6df9e7622bd53">https://preview.redd.it/0ydzf4s4sstg1.png?width=3022&amp;format=png&amp;auto=webp&amp;s=926a41783d8dcabc5350d5ef82f6df9e7622bd53</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/ByteBenderPro"> /u/ByteBenderPro </a> <a href="https://www.reddit.com/r/django/comments/1se127g/fork_of_djangosilk_with_a_rebuilt_ui_n1_detection/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1se127g/fork_of_djangosilk_with_a_rebuilt_ui_n1_detection/">[comments]</a>

Been using django-silk for a while. The profiling is great but I kept hitting
 the same UI papercuts: single-value filter dropdowns, a drawer that eats half
 your screen, no real pagination.
 Built a fork called django-silky.
 The part I'm most happy with is N+1 detection. Silk already captures every SQL query so I added a fingerprinting pass per request. If the same structural query fires 3+ times you get an orange banner on the SQL tab showing the pattern, count badge, total ms cost, and the offending rows highlighted in the table. There's a filter toggle to show only N+1 requests across the board.
 https://preview.redd.it/p8zufpkf2ltg1.png?width=3022&format=png&auto=webp&s=b93a5e6889ef283f1cccb8c9c7a9326045e9da3e
 https://preview.redd.it/zmo4ma4h2ltg1.png?width=3022&format=png&auto=webp&s=5826ddf7292b4051e53143e6cb63c3828ad64a01
 Also rebuilt the analytics dashboard with a request activity timeline, status code donut, HTTP method lollipop, response time histogram, and latency percentile curves for both request time and SQL time.
 https://preview.redd.it/hyv2tasj2ltg1.png?width=3022&format=png&auto=webp&s=17f3ae71d9718ef123ccc31add869f0b6f0cf49a
 Same schema as upstream so it's just:
 pip uninstall django-silk && pip install django-silky
 github.com/VaishnavGhenge/django-silky
 UPDATE:
 I updated package with new user selectable color schemes and also improved color contrast issues.
 https://preview.redd.it/t7vu84wzrstg1.png?width=3022&format=png&auto=webp&s=9a724e77cc42c07c61f25baa856cda103c3e834c
 https://preview.redd.it/mf22ngy2sstg1.png?width=3022&format=png&auto=webp&s=0443a502315583e30d0567e3d6a924dfe2a36794
 https://preview.redd.it/0ydzf4s4sstg1.png?width=3022&format=png&auto=webp&s=926a41783d8dcabc5350d5ef82f6df9e7622bd53
    submitted by    /u/ByteBenderPro  
 [link]   [comments]

Fork of django-silk with a rebuilt UI - N+1 detection, analytics dashboard, multi-select filters

<div class="md">I’ve been working on a side project where developers can collaborate on the same project in real time (shared code editor, chat, etc.). The hardest part wasn’t the UI or even Git integration — it was real-time communication. A few things I learned (the hard way): WebSockets work great locally, but production is a different story → timeouts, dropped connections, reverse proxies… everything breaks differently Keeping multiple users in sync is harder than expected → even something simple like a shared editor can create race conditions You need to think about limits early → max payload size, number of participants, memory usage → otherwise you’re basically opening yourself to abuse Debugging real-time systems is painful → logs are not enough, you need good visibility of events I ended up restructuring part of the backend just to handle rooms, connections and cleanup properly. Still far from perfect, but it’s starting to work with real users now (~140). If anyone’s curious, this is what I’m building: <a href="https://www.codekhub.it/">https://www.codekhub.it/</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Heavy_Association633"> /u/Heavy_Association633 </a> <a href="https://www.reddit.com/r/django/comments/1sftkhb/what_i_learned_building_realtime_collaboration/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sftkhb/what_i_learned_building_realtime_collaboration/">[comments]</a>

I’ve been working on a side project where developers can collaborate on the same project in real time (shared code editor, chat, etc.).
 The hardest part wasn’t the UI or even Git integration — it was real-time communication.
 A few things I learned (the hard way):
 WebSockets work great locally, but production is a different story
 → timeouts, dropped connections, reverse proxies… everything breaks differently
 Keeping multiple users in sync is harder than expected
 → even something simple like a shared editor can create race conditions
 You need to think about limits early
 → max payload size, number of participants, memory usage
 → otherwise you’re basically opening yourself to abuse
 Debugging real-time systems is painful
 → logs are not enough, you need good visibility of events
 I ended up restructuring part of the backend just to handle rooms, connections and cleanup properly.
 Still far from perfect, but it’s starting to work with real users now (~140).
 If anyone’s curious, this is what I’m building:
 https://www.codekhub.it/
    submitted by    /u/Heavy_Association633  
 [link]   [comments]

What I learned building real-time collaboration (WebSockets, FastAPI, scaling issues)

&#32; submitted by &#32; <a href="https://www.reddit.com/user/dwaxe"> /u/dwaxe </a> <a href="https://www.djangoproject.com/weblog/2026/apr/07/could-you-host-djangocon-europe-2027-call-for-orga/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sevptk/could_you_host_djangocon_europe_2027_call_for/">[comments]</a>

Could you host DjangoCon Europe 2027? Call for organizers

<div class="md">Hi everyone, This might be a bit of a dumb question, but I’d really appreciate some guidance. I’m building a Django application and I’d like to assign users an ID that is: - human-readable (not something super long or messy like a UUID) - but also not easy to guess or enumerate I know Django already has primary keys and UUIDs, but I’m trying to find a balance between usability and security. For example, something shorter and cleaner than a UUID, but still reasonably safe to expose (e.g. in URLs or tickets). What would be the best approach for this? - Custom generated IDs - Hashing or encoding - Using UUIDs but formatting them differently Also, I know this might not be the best idea from a security standpoint, so feel free to point that out, I’m still learning and just want to understand the right approach. Thanks a lot! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/accountant856"> /u/accountant856 </a> <a href="https://www.reddit.com/r/django/comments/1sfoqzi/how_do_you_generate_short_but_hardtoguess_user/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sfoqzi/how_do_you_generate_short_but_hardtoguess_user/">[comments]</a>

Hi everyone,
 This might be a bit of a dumb question, but I’d really appreciate some guidance.
 I’m building a Django application and I’d like to assign users an ID that is:
 - human-readable (not something super long or messy like a UUID)
 - but also not easy to guess or enumerate
 I know Django already has primary keys and UUIDs, but I’m trying to find a balance between usability and security. For example, something shorter and cleaner than a UUID, but still reasonably safe to expose (e.g. in URLs or tickets).
 What would be the best approach for this?
 - Custom generated IDs
 - Hashing or encoding
 - Using UUIDs but formatting them differently
 Also, I know this might not be the best idea from a security standpoint, so feel free to point that out, I’m still learning and just want to understand the right approach.
 Thanks a lot!
    submitted by    /u/accountant856  
 [link]   [comments]

How do you generate short but hard-to-guess user IDs in Django?

<div class="md">Hi everyone, I&#39;m currently learning backend development with Python, specifically using Django. I haven&#39;t worked in a real job yet, and I&#39;m trying to understand how people improve their skills and keep up with the fast changes in backend development. Do most developers: <ul> <li>Take paid courses?</li> <li>Follow free tutorials?</li> <li>Build personal Django projects?</li> <li>Read Django documentation regularly?</li> <li>Contribute to open source?</li> <li>Practice system design?</li> </ul> Also, since I don&#39;t have professional experience yet, I&#39;m wondering: <ul> <li>How do you know you&#39;re ready for a job?</li> <li>How do you keep up with new Django updates and backend trends?</li> <li>What helped you the most when you were still learning?</li> </ul> I&#39;d really appreciate hearing your experiences and advice. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Om_JR"> /u/Om_JR </a> <a href="https://www.reddit.com/r/django/comments/1seq8xf/how_do_people_improve_their_backend_skills_with/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1seq8xf/how_do_people_improve_their_backend_skills_with/">[comments]</a>

Hi everyone,
 I'm currently learning backend development with Python, specifically using Django. I haven't worked in a real job yet, and I'm trying to understand how people improve their skills and keep up with the fast changes in backend development.
 Do most developers:
  
Take paid courses?
 Follow free tutorials?
 Build personal Django projects?
 Read Django documentation regularly?
 Contribute to open source?
 Practice system design?
  
Also, since I don't have professional experience yet, I'm wondering:
  
How do you know you're ready for a job?
 How do you keep up with new Django updates and backend trends?
 What helped you the most when you were still learning?
  
I'd really appreciate hearing your experiences and advice.
    submitted by    /u/Om_JR  
 [link]   [comments]

How do people improve their backend skills with Django and keep up with new updates?

<div class="md">I am learning Django and i think Core Schafer is a good tutor but his Django course is old its from 2018. So i am wondering if Django courses from 2017 or 2018 still relevant in 2026? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Leading_Property2066"> /u/Leading_Property2066 </a> <a href="https://www.reddit.com/r/django/comments/1sceitv/are_old_django_courses_still_relevant_today/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sceitv/are_old_django_courses_still_relevant_today/">[comments]</a>

I am learning Django and i think Core Schafer is a good tutor but his Django course is old its from 2018. 
 So i am wondering if Django courses from 2017 or 2018 still relevant in 2026?
    submitted by    /u/Leading_Property2066  
 [link]   [comments]

Are Old Django courses still relevant today?

<div class="md">Hey <a href="/r/django">r/django</a> — I&#39;m a self-taught career changer trying to break into my first dev role and I could really use experienced eyes on my project before I keep applying. The project: Skincare Allergy Filter — a full-stack Django 6.0 web app where users build an allergen profile and scan cosmetic ingredient lists for conflicts. 👉 <a href="https://github.com/RJChoe/Skincare-Filter-Web-Application">https://github.com/RJChoe/Skincare-Filter-Web-Application</a> My background: Not a CS grad. Before this I was a LASIK surgery tech and a GIA-certified jeweler. I&#39;ve been self-teaching Python/Django since 2024, completed Harvard&#39;s CS50 Python cert, and have been building this project seriously since September 2025 (300+ commits). Everything else is self-taught from docs, projects, and iteration. What I&#39;ve built: <ul> <li>Custom Django user model, relational DB models with constraints and validation</li> <li>pytest suite with fixtures and branch coverage</li> <li>CI/CD via GitHub Actions + Codecov with enforced coverage thresholds</li> <li>Code quality gates: ruff, mypy, bandit</li> <li>11-document technical documentation suite (architecture, security, deployment, migrations, ops)</li> <li>Gate-based development workflow I designed and managed solo</li> </ul> What I already know is rough: <ul> <li>Early commit messages are bad. I know. They&#39;ve improved significantly in the last week or two, but the history is what it is.</li> <li>Same with early PR descriptions.</li> <li>This is a learning-as-I-go project, so there&#39;s probably a lot I don&#39;t know I don&#39;t know — which is exactly why I&#39;m here.</li> </ul> What I&#39;m hoping you&#39;ll look at: <ol> <li>Is my Django code structured the way a real team would expect? (models, views, project layout)</li> <li>Does my test approach look like I understand what I&#39;m testing, or does it look like I&#39;m just chasing coverage numbers?</li> <li>Is there anything in here that would make a hiring dev immediately close the tab?</li> <li>Anything you&#39;d tell a junior dev to fix or learn next?</li> </ol> I&#39;ve sent 80+ applications and haven&#39;t gotten a single interview. I&#39;m not looking for encouragement — I want to know what&#39;s actually wrong so I can fix it. Brutal honesty appreciated. Thanks in advance. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/NewDance7202"> /u/NewDance7202 </a> <a href="https://www.reddit.com/r/django/comments/1sap4wr/seeking_honest_code_review_django_portfolio/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sap4wr/seeking_honest_code_review_django_portfolio/">[comments]</a>

Hey r/django — I'm a self-taught career changer trying to break into my first dev role and I could really use experienced eyes on my project before I keep applying.
 The project: Skincare Allergy Filter — a full-stack Django 6.0 web app where users build an allergen profile and scan cosmetic ingredient lists for conflicts. 👉 https://github.com/RJChoe/Skincare-Filter-Web-Application
 My background: Not a CS grad. Before this I was a LASIK surgery tech and a GIA-certified jeweler. I've been self-teaching Python/Django since 2024, completed Harvard's CS50 Python cert, and have been building this project seriously since September 2025 (300+ commits). Everything else is self-taught from docs, projects, and iteration.
 What I've built:
  
Custom Django user model, relational DB models with constraints and validation
 pytest suite with fixtures and branch coverage
 CI/CD via GitHub Actions + Codecov with enforced coverage thresholds
 Code quality gates: ruff, mypy, bandit
 11-document technical documentation suite (architecture, security, deployment, migrations, ops)
 Gate-based development workflow I designed and managed solo
  
What I already know is rough:
  
Early commit messages are bad. I know. They've improved significantly in the last week or two, but the history is what it is.
 Same with early PR descriptions.
 This is a learning-as-I-go project, so there's probably a lot I don't know I don't know — which is exactly why I'm here.
  
What I'm hoping you'll look at:
  
Is my Django code structured the way a real team would expect? (models, views, project layout)
 Does my test approach look like I understand what I'm testing, or does it look like I'm just chasing coverage numbers?
 Is there anything in here that would make a hiring dev immediately close the tab?
 Anything you'd tell a junior dev to fix or learn next?
  
I've sent 80+ applications and haven't gotten a single interview. I'm not looking for encouragement — I want to know what's actually wrong so I can fix it. Brutal honesty appreciated.
 Thanks in advance.
    submitted by    /u/NewDance7202  
 [link]   [comments]

Seeking honest code review — Django portfolio project (self-taught career changer, 80+ apps, 0 interviews)

<div class="md">Hi devs, I&#39;ve been dealing with migration headaches on team projects — conflicts from parallel branches, unsafe operations slipping into production, and non-reversible data migrations breaking rollbacks. Problem: Django&#39;s built-in tools detect conflicts but don&#39;t tell you if merging is safe or flag risky patterns. So I built django-migration-doctor — a management command that adds the missing safety layer. What it does: <ul> <li>Conflict detection — finds parallel migration branches and tells you if auto-merging is safe</li> <li>(analyzes whether operations touch the same fields, checks for destructive ops)</li> <li>Safety classification — classifies every operation as SAFE/RISKY/UNSAFE</li> <li>(e.g., AddField with null=True → SAFE, RemoveField → UNSAFE)</li> <li>Migration linting — 4 built-in rules: <ul> <li>RunPython/RunSQL without reverse code</li> <li>Non-nullable AddField without a default (will crash on existing rows)</li> <li>Field/model renames (break code references silently)</li> <li>AddIndex without CONCURRENTLY (locks tables on Postgres)</li> </ul></li> <li>CI integration — <code>drmigrate check</code> returns exit codes, supports JSON and GitHub Actions annotations</li> </ul> Usage is simple: <pre><code> pip install django-migration-doctor python manage.py drmigrate check # CI mode python manage.py drmigrate conflicts # conflict analysis python manage.py drmigrate lint # lint rules python manage.py drmigrate safety # safety report </code></pre> It&#39;s plugin-friendly, and you can write custom lint rules and register them via settings. Links: <ul> <li>PyPI: <a href="https://pypi.org/project/django-migration-doctor/">https://pypi.org/project/django-migration-doctor/</a></li> <li>GitHub: <a href="https://github.com/moeezsaiyam/django-migration-doctor">https://github.com/moeezsaiyam/django-migration-doctor</a></li> </ul> Would love the community feedback, feature requests, or contributions. What migration pain points do you deal with that this doesn&#39;t cover yet? Happy Coding 👨🏼‍💻 </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/moeez_saiyam"> /u/moeez_saiyam </a> <a href="https://www.reddit.com/r/django/comments/1sf93cz/developed_djangomigrationdoctor_a_migration/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sf93cz/developed_djangomigrationdoctor_a_migration/">[comments]</a>

Hi devs,
 I've been dealing with migration headaches on team projects — conflicts from parallel branches, unsafe operations slipping into production, and non-reversible data migrations breaking rollbacks.
 Problem: Django's built-in tools detect conflicts but don't tell you if merging is safe or flag risky patterns.
 So I built django-migration-doctor — a management command that adds the missing safety layer.
 What it does:
  
Conflict detection — finds parallel migration branches and tells you if auto-merging is safe
 (analyzes whether operations touch the same fields, checks for destructive ops)
 Safety classification — classifies every operation as SAFE/RISKY/UNSAFE
 (e.g., AddField with null=True → SAFE, RemoveField → UNSAFE)
 Migration linting — 4 built-in rules: 
 RunPython/RunSQL without reverse code
 Non-nullable AddField without a default (will crash on existing rows)
 Field/model renames (break code references silently)
 AddIndex without CONCURRENTLY (locks tables on Postgres)
 
 CI integration — drmigrate check returns exit codes, supports JSON and GitHub Actions annotations
  
Usage is simple:
  pip install django-migration-doctor python manage.py drmigrate check # CI mode python manage.py drmigrate conflicts # conflict analysis python manage.py drmigrate lint # lint rules python manage.py drmigrate safety # safety report 
 It's plugin-friendly, and you can write custom lint rules and register them via settings.
 Links:
  
PyPI: https://pypi.org/project/django-migration-doctor/
 GitHub: https://github.com/moeezsaiyam/django-migration-doctor
  
Would love the community feedback, feature requests, or contributions. What migration pain points do you deal with that this doesn't cover yet?
 Happy Coding 👨🏼‍💻
    submitted by    /u/moeez_saiyam  
 [link]   [comments]

Developed django-migration-doctor — a migration linting and conflict resolution tool for Django teams

<div class="md">I’ve have previously experimented with Django Q but never deployed it to a production environment. I love the simplicity getting Django Q running in a project but thinking about dockerizing the setup seems less straight forward. Now I wonder how I’d run/start Gunicorn and qcluster inside the same docker container. Or should those two even run in the same container? Are there reasons not to run the two inside the same container? I found references to supervisord but I am wondering if that is the way to go or if there are others. EDIT: I decided to stick with django-q2 and solved my initial problem by defining two services in my docker compose file. Out reference the same code base/django project. One service starts Django and one starts qcluster. That seems to do the job and is pretty straight forward. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/waddehaddedudedah"> /u/waddehaddedudedah </a> <a href="https://www.reddit.com/r/django/comments/1se5lnv/how_to_run_django_django_q_in_docker/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1se5lnv/how_to_run_django_django_q_in_docker/">[comments]</a>

I’ve have previously experimented with Django Q but never deployed it to a production environment. I love the simplicity getting Django Q running in a project but thinking about dockerizing the setup seems less straight forward.
 Now I wonder how I’d run/start Gunicorn and qcluster inside the same docker container.
 Or should those two even run in the same container? Are there reasons not to run the two inside the same container?
 I found references to supervisord but I am wondering if that is the way to go or if there are others.
 EDIT: I decided to stick with django-q2 and solved my initial problem by defining two services in my docker compose file. Out reference the same code base/django project. One service starts Django and one starts qcluster. That seems to do the job and is pretty straight forward.
    submitted by    /u/waddehaddedudedah  
 [link]   [comments]

How to run Django + Django Q in Docker

<div class="md">Made a small Django app for Stripe-style IDs. The main thing is your endpoints can accept multiple identifiers (UUID, slug, etc) for the same object. In a bigger API you always end up with the “wrong” ID in logs/admin/urls and have to translate it. This removes that step. No extra queries, just works with Django + DRF. GitHub: <a href="https://github.com/josephabrahams/django-display-ids">https://github.com/josephabrahams/django-display-ids</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/josephabrahams"> /u/josephabrahams </a> <a href="https://pypi.org/project/django-display-ids/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sfwif9/stripelike_prefixed_ids_for_django_uuidslug/">[comments]</a>

Made a small Django app for Stripe-style IDs. The main thing is your endpoints can accept multiple identifiers (UUID, slug, etc) for the same object.
 In a bigger API you always end up with the “wrong” ID in logs/admin/urls and have to translate it. This removes that step. No extra queries, just works with Django + DRF.
 GitHub: https://github.com/josephabrahams/django-display-ids
    submitted by    /u/josephabrahams  
 [link]   [comments]

Stripe-like prefixed IDs for Django (+ uuid/slug support)

<div class="md">I&#39;ve been building out <a href="https://djangocontrolroom.com">Django Control Room</a>, a suite of operational tools and framework for building tools right inside the django admin. The latest addition is signals panel that shows: <ul> <li>All registered signals</li> <li>All connected recievers</li> <li>where they are defined</li> <li>code snippets for each reciever</li> </ul> Signals are hard; They are often a pain point for django developers to the extent that people swear off them entirely. Hopefully with more information, signals can be demystified for many and people may find more use for them in their workflow. You can check out dj-signals-panel now, available as both a standalone package or as a part of the django control room ecosystem: repo: <a href="https://github.com/yassi/dj-signals-panel">https://github.com/yassi/dj-signals-panel</a> Django control room: <a href="https://djangocontrolroom.com/">https://djangocontrolroom.com/</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/yassi_dev"> /u/yassi_dev </a> <a href="https://github.com/yassi/dj-signals-panel">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1se1c8w/djsignalspanel_inspect_signals_and_receivers_and/">[comments]</a>

I've been building out Django Control Room, a suite of operational tools and framework for building tools right inside the django admin.
 The latest addition is signals panel that shows:
  
All registered signals
 All connected recievers
 where they are defined
 code snippets for each reciever
  
Signals are hard; They are often a pain point for django developers to the extent that people swear off them entirely. Hopefully with more information, signals can be demystified for many and people may find more use for them in their workflow. 
 You can check out dj-signals-panel now, available as both a standalone package or as a part of the django control room ecosystem:
 repo: https://github.com/yassi/dj-signals-panel
 Django control room: https://djangocontrolroom.com/
    submitted by    /u/yassi_dev  
 [link]   [comments]

dj-signals-panel: Inspect signals and receivers and code right inside the django admin

&#32; submitted by &#32; <a href="https://www.reddit.com/user/tbhaxor"> /u/tbhaxor </a> <a href="/r/selfhosted/comments/1sb7nzk/proxyforge_solving_ip_throttling/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sb7oko/proxyforge_solving_ip_throttling/">[comments]</a>

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

ProxyForge - Solving IP Throttling

<div class="md">Is Django 5 By Example outdated? Do you guys have any books relevant for Django 6 that I can use to learn on top of the official documentation (part 1 to 8)? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/letsgo_iyz"> /u/letsgo_iyz </a> <a href="https://www.reddit.com/r/django/comments/1sdnria/django_5_by_example_should_i_learn_using_this/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sdnria/django_5_by_example_should_i_learn_using_this/">[comments]</a>

Is Django 5 By Example outdated? Do you guys have any books relevant for Django 6 that I can use to learn on top of the official documentation (part 1 to 8)?
    submitted by    /u/letsgo_iyz  
 [link]   [comments]

Django 5 By Example: Should I learn using this book in 2026?

<div class="md">Hi. How would i run a specific task that has to read data from database and make request to specific url in django. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Imaginary_Food_7102"> /u/Imaginary_Food_7102 </a> <a href="https://www.reddit.com/r/django/comments/1sd2t2h/run_task_on_backend/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sd2t2h/run_task_on_backend/">[comments]</a>

Hi. How would i run a specific task that has to read data from database and make request to specific url in django.
    submitted by    /u/Imaginary_Food_7102  
 [link]   [comments]

Run task on backend

<div class="md">We have developed an open source django and celery based web app for computation of spatial overlap between contours as well as for computation of STAPLE contours for use in radiation oncology. Repo here: <a href="https://github.com/CHAVI-India/COMET">https://github.com/CHAVI-India/COMET</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/indianradonc"> /u/indianradonc </a> <a href="https://www.reddit.com/r/django/comments/1sff69j/comet_contour_metrics/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sff69j/comet_contour_metrics/">[comments]</a>

We have developed an open source django and celery based web app for computation of spatial overlap between contours as well as for computation of STAPLE contours for use in radiation oncology. Repo here: https://github.com/CHAVI-India/COMET
    submitted by    /u/indianradonc  
 [link]   [comments]

COMET (COntour METrics)

<div class="md">Hi all, I have created a data quality checker (Python, Django) for non-SQL professionals. Quality checker includes the number of null values per column, along with a separate page that shows detailed information about null entries—such as their index and corresponding column. The results also highlight any duplicate rows and provide the outcome of the schema validation. The reason behind this project is that often when working in analytics I was working with various different CSV or Excel files that were prepared by professionals who worked in different roles, and thought that it would be good to have a simple to use tool that would enable these professionals to quickly check for null values, duplicate rows and even perform schema validation. Needles to say, sometimes these are intended values, but even so, it would be nice to have that feedback upfront. I have enabled PDF download of validation results as well, login &amp; am working on archive. Repository is here: <a href="https://github.com/samksenija/Data-Quality-Checker">https://github.com/samksenija/Data-Quality-Checker</a> Looking forward to feedback! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/legolas_xx_00"> /u/legolas_xx_00 </a> <a href="https://www.reddit.com/r/django/comments/1sgm4mo/data_quality_checker_for_nonsql_professionals/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sgm4mo/data_quality_checker_for_nonsql_professionals/">[comments]</a>

Hi all, I have created a data quality checker (Python, Django) for non-SQL professionals.
 Quality checker includes the number of null values per column, along with a separate page that shows detailed information about null entries—such as their index and corresponding column. The results also highlight any duplicate rows and provide the outcome of the schema validation.
 The reason behind this project is that often when working in analytics I was working with various different CSV or Excel files that were prepared by professionals who worked in different roles, and thought that it would be good to have a simple to use tool that would enable these professionals to quickly check for null values, duplicate rows and even perform schema validation. Needles to say, sometimes these are intended values, but even so, it would be nice to have that feedback upfront.
 I have enabled PDF download of validation results as well, login & am working on archive.
 Repository is here: https://github.com/samksenija/Data-Quality-Checker
 Looking forward to feedback!
    submitted by    /u/legolas_xx_00  
 [link]   [comments]

Hello, Python

Python Jobs 💼