<div class="md">Hello everyone, I am currently running my business off a VPS running WooCommerce. I am unhappy with the limitations of WordPress, and want to look into Django. I have a pretty good understanding of Python, and I am not in a hurry to switch. Is there any framework for e-commerce that works within Django? I have looked online, and by the looks of it, I&#39;d have to build all the e-commerce functionality myself. I might be misinformed, simply because I don&#39;t know Django at all. Anyone have any insight into how to go about this? Where would efforts best be spent in educating myself. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Ducking_eh"> /u/Ducking_eh </a> <a href="https://www.reddit.com/r/djangolearning/comments/1sgxevq/ecommerce_on_django/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1sgxevq/ecommerce_on_django/">[comments]</a>

Hello everyone,
 I am currently running my business off a VPS running WooCommerce.
 I am unhappy with the limitations of WordPress, and want to look into Django.
 I have a pretty good understanding of Python, and I am not in a hurry to switch.
 Is there any framework for e-commerce that works within Django?
 I have looked online, and by the looks of it, I'd have to build all the e-commerce functionality myself. I might be misinformed, simply because I don't know Django at all.
 Anyone have any insight into how to go about this? Where would efforts best be spent in educating myself.
    submitted by    /u/Ducking_eh  
 [link]   [comments]

E-commerce on django

<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">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.

<table> <tr><td> <a href="https://www.reddit.com/r/flask/comments/1sh52zo/pow_shield_test_2_localhost_in_the_front/"> <img src="https://external-preview.redd.it/bGh0cjF0Zm92OHVnMUToZ1IBV74wBwGjMmtUi8nbYz4QfHj5U_sNW4wMIYGd.png?width=640&amp;crop=smart&amp;auto=webp&amp;s=0cd972dddddc1c02f472ad2f30222177928224e5" alt="pow shield test 2 (localhost in the front, neocities in the back)" title="pow shield test 2 (localhost in the front, neocities in the back)" /> </a> </td><td> &#32; submitted by &#32; <a href="https://www.reddit.com/user/WW92030"> /u/WW92030 </a> <a href="https://v.redd.it/w659mefov8ug1">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1sh52zo/pow_shield_test_2_localhost_in_the_front/">[comments]</a> </td></tr></table>

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

pow shield test 2 (localhost in the front, neocities in the back)

<div class="md">My company (JigsawML) builds a scanner that reads a software repo and outputs architectural diagrams. I persuaded them to provide a version that will read the Flask repo with a single button (no signups). If you add &quot;/open-source-projects&quot; to the company URL, it will take you directly to the scanner. I put this in the link section. I&#39;ve left a few screenshots so that you can get a sense of what it does. In the next few weeks, diffs and deeper granularity will be added. Oh yes, you can ask questions about the architecture using an &quot;Ask AI&quot; capability. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/CraterLakeGodzilla"> /u/CraterLakeGodzilla </a> <a href="https://www.reddit.com/r/flask/comments/1sgxauv/queryable_sw_architecture_diagram_for_flask_repo/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1sgxauv/queryable_sw_architecture_diagram_for_flask_repo/">[comments]</a>

My company (JigsawML) builds a scanner that reads a software repo and outputs architectural diagrams. I persuaded them to provide a version that will read the Flask repo with a single button (no signups). 
 If you add "/open-source-projects" to the company URL, it will take you directly to the scanner. I put this in the link section.
 I've left a few screenshots so that you can get a sense of what it does.
 In the next few weeks, diffs and deeper granularity will be added. Oh yes, you can ask questions about the architecture using an "Ask AI" capability.
    submitted by    /u/CraterLakeGodzilla  
 [link]   [comments]

Queryable SW Architecture Diagram for Flask Repo

<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">I’m currently using AWS lambda / APIGateway to host my FastAPI server. There’s a ton of code to make this work and other stuff that I’m the only person in my team understands. Had to switch from Mangin back to using uvicorn to serve because I wanted streamed responses, and to make things start fast we use Snapstart, which is also a whole thing. I was considering switching over to using Modal, but found out about FastAPI Cloud. Cloud sounds awesome, but I’m pretty sure I can replace my job system with function calls on Modal. I don’t see an equivalent out of the box job system managed by Cloud. Has anyone tried both? Any reason to use Cloud over Modal? Still too early to tell with Cloud? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/MichaelEvo"> /u/MichaelEvo </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sgrdo3/fastapi_cloud_vs_modal/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sgrdo3/fastapi_cloud_vs_modal/">[comments]</a>

I’m currently using AWS lambda / APIGateway to host my FastAPI server. There’s a ton of code to make this work and other stuff that I’m the only person in my team understands. Had to switch from Mangin back to using uvicorn to serve because I wanted streamed responses, and to make things start fast we use Snapstart, which is also a whole thing.
 I was considering switching over to using Modal, but found out about FastAPI Cloud. Cloud sounds awesome, but I’m pretty sure I can replace my job system with function calls on Modal. I don’t see an equivalent out of the box job system managed by Cloud.
 Has anyone tried both? Any reason to use Cloud over Modal? Still too early to tell with Cloud?
    submitted by    /u/MichaelEvo  
 [link]   [comments]

FastAPI Cloud vs Modal

<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

<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?

<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

<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!

&#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">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">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">&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">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">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">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)

<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">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?

&#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, 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">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 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">I&#39;m a Computer Science student and for our pseudo-internship, we are taking over another team&#39;s Django website. It uses Django as back end and another framework as front end. In the code that returns database information, I see: <code>from django_filters.rest_framework import DjangoFilterBackend, FilterSet</code> <code>from rest_framework import filters</code> this is in addition to normal QuerySet() filters in the model code. While there are separate documentation for all 3, I wonder if experts here can explain why all 3 are needed (or maybe not needed but preferred). </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/AyrtonHS"> /u/AyrtonHS </a> <a href="https://www.reddit.com/r/django/comments/1sh78sj/is_there_a_need_for_3_filtering_systems/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sh78sj/is_there_a_need_for_3_filtering_systems/">[comments]</a>

I'm a Computer Science student and for our pseudo-internship, we are taking over another team's Django website. It uses Django as back end and another framework as front end.
 In the code that returns database information, I see:
 from django_filters.rest_framework import DjangoFilterBackend, FilterSet
 from rest_framework import filters
 this is in addition to normal QuerySet() filters in the model code. While there are separate documentation for all 3, I wonder if experts here can explain why all 3 are needed (or maybe not needed but preferred).
    submitted by    /u/AyrtonHS  
 [link]   [comments]

Is there a need for 3 filtering "systems"?

<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’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">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

<div class="md">Estoy buscando un lugar donde charlar, donde emocionarse con los nuevos features, donde plantear ideas y hacer comunidad, donde podamos pensar en una app y hacerla en algunas tardes solo para probar cosas. Un lugar donde quizá no sea para aprender de 0, algo más para compartir formas de trabajo, ideas, cómo resolver problemas grandes, y poder ejercer el Rubber Duck pero con personas, ayudar en proyectos, algún lugar donde nos podamos sentar a programar. ¿Habrá alguna? Este sub es muy interesante, pero creo que estaría bien poder hacer incluso retos de x cosas y ver las diversas formas de resolverlo. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Jolly-Play3558"> /u/Jolly-Play3558 </a> <a href="https://www.reddit.com/r/django/comments/1sheywl/existe_algún_discord_con_comunidad_activa_sobre/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sheywl/existe_algún_discord_con_comunidad_activa_sobre/">[comments]</a>

Estoy buscando un lugar donde charlar, donde emocionarse con los nuevos features, donde plantear ideas y hacer comunidad, donde podamos pensar en una app y hacerla en algunas tardes solo para probar cosas. Un lugar donde quizá no sea para aprender de 0, algo más para compartir formas de trabajo, ideas, cómo resolver problemas grandes, y poder ejercer el Rubber Duck pero con personas, ayudar en proyectos, algún lugar donde nos podamos sentar a programar.
 ¿Habrá alguna?
 Este sub es muy interesante, pero creo que estaría bien poder hacer incluso retos de x cosas y ver las diversas formas de resolverlo.
    submitted by    /u/Jolly-Play3558  
 [link]   [comments]

¿Existe algún discord con comunidad activa sobre django en español?

<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">Who do you use for transactional emails like confirming use email address, password resets, etc? I&#39;d eventually like to send email invites through my app. I&#39;m leaning towards Sender, Resend, Mailtrap, or Brevo. I considered SES and as a dev I think I could figure out the setup, but I&#39;ve read stories of people getting rejected from using it in production. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/nuevedientes"> /u/nuevedientes </a> <a href="https://www.reddit.com/r/django/comments/1si0ms6/transactional_email/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1si0ms6/transactional_email/">[comments]</a>

Who do you use for transactional emails like confirming use email address, password resets, etc? I'd eventually like to send email invites through my app. I'm leaning towards Sender, Resend, Mailtrap, or Brevo. I considered SES and as a dev I think I could figure out the setup, but I've read stories of people getting rejected from using it in production. 
    submitted by    /u/nuevedientes  
 [link]   [comments]

Transactional email

<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

&#32; submitted by &#32; <a href="https://www.reddit.com/user/thibaudcolas"> /u/thibaudcolas </a> <a href="https://wagtail.org/blog/ai-and-developer-experience-wagtail-community-survey/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1shllo3/ai_and_developer_experience_wagtail_community/">[comments]</a>

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

AI and Developer Experience: Wagtail community survey

<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]

Hello, Python

Python Jobs 💼