<div class="md">Nothing new here, a while ago I needed to add OAuth login to a FastAPI project. [<a href="https://github.com/pranavkumaarofficial/oauth-for-dummies">REPO</a>] But as u know: I kept running into the same setup work: <pre><code>- redirect URI mismatches - provider-specific config - state handling - callback routes - env variables - example code that was either too abstract or incomplete </code></pre> So I spent some time turning the setup I kept rewriting into a small open-source package: [<a href="https://github.com/pranavkumaarofficial/oauth-for-dummies">REPO</a>] Install: <pre><code>pip install oauth-for-dummies </code></pre> Then inside a FastAPI project: <pre><code>oauth-init </code></pre> It scaffolds: <pre><code>- oauth_config.py - oauth_routes.py - oauth_example_app.py - .env template </code></pre> Right now it supports GitHub and Google OAuth. The goal is not to replace serious production auth platforms. It is more for prototypes, internal tools, learning projects, and people who want readable OAuth code they can actually modify. I kinda use this a lot to build internal applications at work: hence this is super useful for me. And it literally solves most of the &quot;auth&quot; part of any application, and I never build the user database or store passwords (for internal tools I meant) I’d appreciate feedback from users, this was just a quick impromptu build. Just wanted to share this to help anyone who finds this useful, And yes: i can add the 2.1 requirement almost easily too. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/theRealSachinSpk"> /u/theRealSachinSpk </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sqplkf/i_got_tired_of_rebuilding_oauth_for_fastapi/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sqplkf/i_got_tired_of_rebuilding_oauth_for_fastapi/">[comments]</a>

Nothing new here, a while ago I needed to add OAuth login to a FastAPI project. [REPO]
 But as u know: I kept running into the same setup work:
 - redirect URI mismatches - provider-specific config - state handling - callback routes - env variables - example code that was either too abstract or incomplete 
 So I spent some time turning the setup I kept rewriting into a small open-source package: [REPO]
 Install:
 pip install oauth-for-dummies 
 Then inside a FastAPI project:
 oauth-init 
 It scaffolds:
 - oauth_config.py - oauth_routes.py - oauth_example_app.py - .env template 
 Right now it supports GitHub and Google OAuth.
 The goal is not to replace serious production auth platforms. It is more for prototypes, internal tools, learning projects, and people who want readable OAuth code they can actually modify. I kinda use this a lot to build internal applications at work: hence this is super useful for me. And it literally solves most of the "auth" part of any application, and I never build the user database or store passwords (for internal tools I meant)
 I’d appreciate feedback from users, this was just a quick impromptu build. Just wanted to share this to help anyone who finds this useful, 
 And yes: i can add the 2.1 requirement almost easily too.
    submitted by    /u/theRealSachinSpk  
 [link]   [comments]

I got tired of rebuilding OAuth for FastAPI projects, so I made a small CLI for it

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1spu0tq/fastapi_backgroundtasks_with_retries_a_live/"> <img src="https://preview.redd.it/jdo58ggym5wg1.png?width=140&amp;height=75&amp;auto=webp&amp;s=b965e3fae67c2b4ac6c970ee0f9c6d4ec4613a22" alt="FastAPI BackgroundTasks with retries, a live dashboard, persistence, and no broker." title="FastAPI BackgroundTasks with retries, a live dashboard, persistence, and no broker." /> </a> </td><td> <div class="md">A few weeks ago I posted about <code>fastapi-taskflow</code>, a library that adds retries, a live dashboard, persistence, and task visibility on top of FastAPI&#39;s native <code>BackgroundTasks</code> without replacing it or requiring a broker. Since then I have added more features and I want to get real feedback from people actually building with FastAPI before I keep adding more features. Give it a try and let me know what you think. <pre><code>pip install fastapi-taskflow </code></pre> Source: <a href="https://github.com/Attakay78/fastapi-taskflow">https://github.com/Attakay78/fastapi-taskflow</a> Docs: <a href="https://attakay78.github.io/fastapi-taskflow/">https://attakay78.github.io/fastapi-taskflow/</a> A quick summary of what it does today: <ul> <li>Retries with delay and exponential backoff per function</li> <li>Task IDs and lifecycle tracking: <code>PENDING</code>, <code>RUNNING</code>, <code>SUCCESS</code>, <code>FAILED</code>, <code>INTERRUPTED</code></li> <li>Live dashboard at <code>/tasks/dashboard</code> with filtering, search, per-task logs, and stack traces</li> <li>SQLite out of the box, Redis as an optional extra</li> <li>Pending tasks at shutdown are re-dispatched on next startup</li> <li>Idempotency keys to prevent duplicate runs</li> <li>Argument encryption for tasks carrying sensitive data</li> <li>Concurrency controls: opt-in semaphore for async tasks, dedicated thread pool for sync tasks</li> </ul> It is not a distributed task queue. No broker, no separate workers. It does support multi-instance deployments with SQLite on the same host or Redis across hosts, with atomic requeue claiming and shared task history. But tasks still run inside the web process, not on dedicated workers. If you use <code>BackgroundTasks</code> in production and give it a try, I would love to hear what works, what does not, and what you wish it did differently. <a href="https://preview.redd.it/jdo58ggym5wg1.png?width=3012&amp;format=png&amp;auto=webp&amp;s=adc7e224a8d3b097518b654d37d58558a9a0e9fc">Dashboard</a> <a href="https://preview.redd.it/f2wbwhgym5wg1.png?width=3012&amp;format=png&amp;auto=webp&amp;s=a0b48abeff2e6c3f390b1669b3e9df7bf7d88cf8">Error stack view</a> <a href="https://preview.redd.it/2c5mhggym5wg1.png?width=3012&amp;format=png&amp;auto=webp&amp;s=46dfc941232abc441a0f5cb1146c205ae6375d61">Logs View</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/1spu0tq/fastapi_backgroundtasks_with_retries_a_live/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1spu0tq/fastapi_backgroundtasks_with_retries_a_live/">[comments]</a> </td></tr></table>

A few weeks ago I posted about fastapi-taskflow, a library that adds retries, a live dashboard, persistence, and task visibility on top of FastAPI's native BackgroundTasks without replacing it or requiring a broker.
 Since then I have added more features and I want to get real feedback from people actually building with FastAPI before I keep adding more features.
 Give it a try and let me know what you think.
 pip install fastapi-taskflow 
 Source: https://github.com/Attakay78/fastapi-taskflow
 Docs: https://attakay78.github.io/fastapi-taskflow/
 A quick summary of what it does today:
  
Retries with delay and exponential backoff per function
 Task IDs and lifecycle tracking: PENDING, RUNNING, SUCCESS, FAILED, INTERRUPTED
 Live dashboard at /tasks/dashboard with filtering, search, per-task logs, and stack traces
 SQLite out of the box, Redis as an optional extra
 Pending tasks at shutdown are re-dispatched on next startup
 Idempotency keys to prevent duplicate runs
 Argument encryption for tasks carrying sensitive data
 Concurrency controls: opt-in semaphore for async tasks, dedicated thread pool for sync tasks
  
It is not a distributed task queue. No broker, no separate workers. It does support multi-instance deployments with SQLite on the same host or Redis across hosts, with atomic requeue claiming and shared task history. But tasks still run inside the web process, not on dedicated workers.
 If you use BackgroundTasks in production and give it a try, I would love to hear what works, what does not, and what you wish it did differently.
 Dashboard
 Error stack view
 Logs View
    submitted by    /u/Educational-Hope960  
 [link]   [comments]

FastAPI BackgroundTasks with retries, a live dashboard, persistence, and no broker.

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1sn4qdw/i_built_archunit_for_python_enforce_architecture/"> <img src="https://external-preview.redd.it/QEMbFJik1ifoXLHmdkjeFhYNxvKZbC_flyGhEeS-RUY.png?width=640&amp;crop=smart&amp;auto=webp&amp;s=02b5a571796257d8389a6e1300584c7199cc441e" alt="I built ArchUnit for Python: enforce architecture rules as unit tests." title="I built ArchUnit for Python: enforce architecture rules as unit tests." /> </a> </td><td> <div class="md">I just shipped ArchUnitPython, a library that lets you enforce architectural rules in Python projects through automated tests. The problem it solves: as codebases grow, architecture erodes. Someone imports the database layer from the presentation layer, circular dependencies creep in, naming conventions drift. Code review catches some of it, but not all, and definitely not consistently. This problem has always existed but is more important than ever in Claude Code, Codex times. LLMs break architectural rules all the time. So I built a library where you define your architecture rules as tests. Two quick examples: ```python <h1>No circular dependencies in services</h1> rule = project_files(&quot;src/&quot;).in_folder(&quot;/services/&quot;).should().have_no_cycles() assert_passes(rule) ``` ```python <h1>Presentation layer must not depend on database layer</h1> rule = project_files(&quot;src/&quot;) .in_folder(&quot;/presentation/&quot;) .should_not() .depend_on_files() .in_folder(&quot;/database/&quot;) assert_passes(rule) ``` This will run in pytest, unittest, or whatever you use, and therefore be automatically in your CI/CD. If a commit violates the architecture rules your team has decided, the CI will fail. Hint: this is exactly what the famous ArchUnit Java library does, just for Python - I took inspiration for the name is of course. Let me quickly address why this over linters or generic code analysis? Linters catch style issues. This catches structural violations — wrong dependency directions, layering breaches, naming convention drift. It&#39;s the difference between &quot;this line looks wrong&quot; and &quot;this module shouldn&#39;t talk to that module.&quot; Some key features: <ul> <li>Dependency direction enforcement &amp; circular dependency detection</li> <li>Naming convention checks (glob + regex)</li> <li>Code metrics: LCOM cohesion, abstractness, instability, distance from main sequence</li> <li>PlantUML diagram validation — ensure code matches your architecture diagrams</li> <li>Custom rules &amp; metrics</li> <li>Zero runtime dependencies, uses only Python&#39;s ast module</li> <li>Python 3.10+</li> </ul> Very curious what you think! <a href="https://github.com/LukasNiessen/ArchUnitPython">https://github.com/LukasNiessen/ArchUnitPython</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/trolleid"> /u/trolleid </a> <a href="https://github.com/LukasNiessen/ArchUnitPython">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sn4qdw/i_built_archunit_for_python_enforce_architecture/">[comments]</a> </td></tr></table>

I just shipped ArchUnitPython, a library that lets you enforce architectural rules in Python projects through automated tests.
 The problem it solves: as codebases grow, architecture erodes. Someone imports the database layer from the presentation layer, circular dependencies creep in, naming conventions drift. Code review catches some of it, but not all, and definitely not consistently.
 This problem has always existed but is more important than ever in Claude Code, Codex times. LLMs break architectural rules all the time.
 So I built a library where you define your architecture rules as tests. Two quick examples:
 ```python
 No circular dependencies in services
 rule = project_files("src/").in_folder("/services/").should().have_no_cycles() assert_passes(rule) ```
 ```python
 Presentation layer must not depend on database layer
 rule = project_files("src/") .in_folder("/presentation/") .should_not() .depend_on_files() .in_folder("/database/") assert_passes(rule) ```
 This will run in pytest, unittest, or whatever you use, and therefore be automatically in your CI/CD. If a commit violates the architecture rules your team has decided, the CI will fail.
 Hint: this is exactly what the famous ArchUnit Java library does, just for Python - I took inspiration for the name is of course.
 Let me quickly address why this over linters or generic code analysis?
 Linters catch style issues. This catches structural violations — wrong dependency directions, layering breaches, naming convention drift. It's the difference between "this line looks wrong" and "this module shouldn't talk to that module."
 Some key features:
  
Dependency direction enforcement & circular dependency detection
 Naming convention checks (glob + regex)
 Code metrics: LCOM cohesion, abstractness, instability, distance from main sequence
 PlantUML diagram validation — ensure code matches your architecture diagrams
 Custom rules & metrics
 Zero runtime dependencies, uses only Python's ast module
 Python 3.10+
  
Very curious what you think! https://github.com/LukasNiessen/ArchUnitPython
    submitted by    /u/trolleid  
 [link]   [comments]

I built ArchUnit for Python: enforce architecture rules as unit tests.

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1sqkwl9/i_built_uigen_to_autogenerate_react_frontends/"> <img src="https://preview.redd.it/afypb6nkjbwg1.gif?width=640&amp;crop=smart&amp;s=ba504697ba39eee57aee287ca5449baf022fdd2e" alt="I built UIGen to auto-generate React frontends from FastAPI OpenAPI specs - here's what happened when I used it on a real internal app" title="I built UIGen to auto-generate React frontends from FastAPI OpenAPI specs - here's what happened when I used it on a real internal app" /> </a> </td><td> <div class="md">Hey veryone, So a few days back, I shared UIGen here - a tool that generates a full React frontend from your FastAPI OpenAPI spec. The response was very encouraging. So I iterated on it with a better usecase app. <h3>The Test Case: AI powered Meeting Minutes Generator</h3> I needed an internal tool for work. The requirements: - Upload Word templates with Jinja2 variables - Create meetings with audio recordings - Associate multiple templates with each meeting - Fill template data (either AI-generated or manual entry) - Generate Word docs, convert to PDF, merge them in order - Download the final merged PDF Standard CRUD stuff, but with file uploads, many-to-many relationships, and some custom actions. Perfect test case. Backend: FastAPI with async SQLAlchemy, PostgreSQL, Alembic migrations. About 2,000 lines of Python across models, services, repositories, and routers. Full OpenAPI spec auto-generated by FastAPI. Frontend: Pointed UIGen at the generated yaml. <h3>Improvements that were made</h3> 1. Too Much Noise in the UI FastAPI generates comprehensive specs. That&#39;s great for documentation, but not every endpoint needs to be in the UI. I had internal metrics endpoints, health checks. I didn&#39;t want to modify my FastAPI code or the generated spec just to hide these. Fix: Built vendor extension support, starting with <code>x-uigen-ignore</code>. Now I can annotate my OpenAPI spec: <code>yaml paths: /internal/metrics: x-uigen-ignore: true /users: get: x-uigen-ignore: false # Explicitly include post: x-uigen-ignore: true # Hide this specific operation </code> Or better yet, use the config system (using the cli) so the spec stays untouched: ```yaml <h1>.uigen/config.yaml</h1> annotations: POST:/internal/metrics: x-uigen-ignore: true User.internal_id: x-uigen-ignore: true ``` Works on operations, paths, schema properties, and parameters. Operation-level annotations override path-level ones. 2. File Uploads FastAPI makes file uploads trivial with <code>UploadFile</code>. But UIGen had no idea what to do with <code>type: string, format: binary</code> in the spec. Fix: Added file upload detection across both OpenAPI 3.x and Swagger 2.0. UIGen now generates a drag-and-drop file upload component with: - Type validation (images, documents, videos) - Size limits from <code>x-uigen-max-file-size</code> - Preview thumbnails - Proper <code>multipart/form-data</code> handling 3. Ugly Field Labels Pydantic field names like <code>created_at</code>, <code>user_id</code>, and <code>is_active</code> get auto-humanized to &quot;Created At&quot;, &quot;User Id&quot;, &quot;Is Active&quot;. Close, but not always right. And I didn&#39;t want to change my Python code just for UI labels. Fix: Added <code>x-uigen-label</code> vendor extension: ```yaml <h1>In spec or config</h1> User.created_at: x-uigen-label: &quot;Created At&quot; User.user_id: x-uigen-label: &quot;User ID&quot; ``` Now labels are exactly what I want without touching the FastAPI models. 5. Config Without Touching the Spec I wanted to hide internal endpoints, rename ugly field labels, and tweak the UI without modifying my FastAPI code or the generated OpenAPI spec. Fix: Built a config reconciliation system. You create a <code>.uigen/config.yaml</code> file with all your customizations, and UIGen merges them at runtime without touching your source spec: <code>yaml annotations: POST:/internal/metrics: x-uigen-ignore: true User.created_at: x-uigen-label: &quot;Created At&quot; POST:/auth/login: x-uigen-login: true </code> Your spec stays clean, your FastAPI code stays clean, but the UI reflects your preferences. There&#39;s a visual config GUI (<code>npx @uigen-dev/cli config openapi.yaml</code>) so you don&#39;t have to write YAML by hand. Point-and-click to hide endpoints, rename fields, and customize the theme. <h3>What Actually Works Now</h3> After building this app and fixing the gaps, here&#39;s what UIGen generates from my FastAPI spec: <ul> <li>Table views with sorting, pagination, and filtering (query params from the spec)</li> <li>Create/edit forms with validation matching my Pydantic models</li> <li>Detail views with related resource links (meetings → templates)</li> <li>File upload UI for template and recording uploads</li> <li>Custom action buttons - &quot;Generate Documents&quot;, &quot;Convert to PDF&quot;, &quot;Download PDF&quot;</li> <li>Full authentication cycle - login, signup, password reset, token storage, automatic header injection</li> <li>Vendor extensions - <code>x-uigen-ignore</code>, <code>x-uigen-label</code>, <code>x-uigen-login</code> for customization</li> <li>Config GUI - visual editor for annotations and theme customization</li> <li>Dark/light theme toggle</li> </ul> <h3>Try It Yourself</h3> The meeting minutes app is in the UIGen repo as a full example: ```bash git clone <a href="https://github.com/darula-hpp/uigen">https://github.com/darula-hpp/uigen</a> cd examples/apps/fastapi/meeting-minutes <h1>Start backend (FastAPI + PostgreSQL)</h1> docker compose up -d docker compose exec app alembic upgrade head <h1>Generate frontend</h1> cd ../../../ pnpm install &amp;&amp; pnpm build npx @uigen-dev/cli serve examples/apps/fastapi/meeting-minutes/openapi.yaml ``` Or try it on your own FastAPI app: <code>bash npx @uigen-dev/cli serve http://localhost:8000/openapi.json </code> <h3>Limitations</h3> There are still gaps: <ul> <li>Circular references - Deeply nested recursive Pydantic models might skip the deepest levels</li> <li>Complex relationships - Many-to-many with extra fields on the join table needs manual handling</li> <li>Custom validation - Pydantic validators with custom logic don&#39;t translate to the frontend</li> <li>WebSockets - Not supported yet</li> <li>Streaming responses - Not supported</li> <li>GraphQL - OpenAPI/REST only for now</li> <li>Every OAuth variant - Works for Bearer/API Key/Basic, but not every custom auth flow</li> </ul> V1 will probably be suited for internal tools, admin panels, and rapid prototyping. Not a replacement for a polished consumer-facing app with custom UX requirements. But yeah, its an intereting challenge to include even more usecases. <h3>What&#39;s Next</h3> I&#39;m trying to figure out: - Better relationship detection and easy relationship config. - A non bloat way to do layout customizations - Adding Polish &amp; a non Bloat way to configure your app (App name etc) If you&#39;ve built a FastAPI app and want to see what UIGen generates, I&#39;d love feedback. The more real-world specs I test against, the better this gets. GitHub: <a href="https://github.com/darula-hpp/uigen">https://github.com/darula-hpp/uigen</a> npm: <a href="https://www.npmjs.com/package/@uigen-dev/cli">https://www.npmjs.com/package/@uigen-dev/cli</a> Docs: <a href="https://uigen-docs.vercel.app">https://uigen-docs.vercel.app</a> Architecture: <a href="https://uigen-docs.vercel.app/blog/uigen-architecture">https://uigen-docs.vercel.app/blog/uigen-architecture</a> <hr/> Happy to hear what you think. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Prestigious-Bee2093"> /u/Prestigious-Bee2093 </a> <a href="https://i.redd.it/afypb6nkjbwg1.gif">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sqkwl9/i_built_uigen_to_autogenerate_react_frontends/">[comments]</a> </td></tr></table>

Hey veryone, 
 So a few days back, I shared UIGen here - a tool that generates a full React frontend from your FastAPI OpenAPI spec. The response was very encouraging.
 So I iterated on it with a better usecase app.
 The Test Case: AI powered Meeting Minutes Generator
 I needed an internal tool for work. The requirements: - Upload Word templates with Jinja2 variables - Create meetings with audio recordings - Associate multiple templates with each meeting - Fill template data (either AI-generated or manual entry) - Generate Word docs, convert to PDF, merge them in order - Download the final merged PDF
 Standard CRUD stuff, but with file uploads, many-to-many relationships, and some custom actions. Perfect test case.
 Backend: FastAPI with async SQLAlchemy, PostgreSQL, Alembic migrations. About 2,000 lines of Python across models, services, repositories, and routers. Full OpenAPI spec auto-generated by FastAPI.
 Frontend: Pointed UIGen at the generated yaml.
 Improvements that were made
 1. Too Much Noise in the UI
 FastAPI generates comprehensive specs. That's great for documentation, but not every endpoint needs to be in the UI. I had internal metrics endpoints, health checks.
 I didn't want to modify my FastAPI code or the generated spec just to hide these.
 Fix: Built vendor extension support, starting with x-uigen-ignore. Now I can annotate my OpenAPI spec:
 yaml paths: /internal/metrics: x-uigen-ignore: true /users: get: x-uigen-ignore: false # Explicitly include post: x-uigen-ignore: true # Hide this specific operation 
 Or better yet, use the config system (using the cli) so the spec stays untouched:
 ```yaml
 .uigen/config.yaml
 annotations: POST:/internal/metrics: x-uigen-ignore: true User.internal_id: x-uigen-ignore: true ```
 Works on operations, paths, schema properties, and parameters. Operation-level annotations override path-level ones.
 2. File Uploads
 FastAPI makes file uploads trivial with UploadFile. But UIGen had no idea what to do with type: string, format: binary in the spec.
 Fix: Added file upload detection across both OpenAPI 3.x and Swagger 2.0. UIGen now generates a drag-and-drop file upload component with: - Type validation (images, documents, videos) - Size limits from x-uigen-max-file-size - Preview thumbnails - Proper multipart/form-data handling
 3. Ugly Field Labels
 Pydantic field names like created_at, user_id, and is_active get auto-humanized to "Created At", "User Id", "Is Active". Close, but not always right. And I didn't want to change my Python code just for UI labels.
 Fix: Added x-uigen-label vendor extension:
 ```yaml
 In spec or config
 User.created_at: x-uigen-label: "Created At" User.user_id: x-uigen-label: "User ID" ```
 Now labels are exactly what I want without touching the FastAPI models.
 5. Config Without Touching the Spec
 I wanted to hide internal endpoints, rename ugly field labels, and tweak the UI without modifying my FastAPI code or the generated OpenAPI spec.
 Fix: Built a config reconciliation system. You create a .uigen/config.yaml file with all your customizations, and UIGen merges them at runtime without touching your source spec:
 yaml annotations: POST:/internal/metrics: x-uigen-ignore: true User.created_at: x-uigen-label: "Created At" POST:/auth/login: x-uigen-login: true 
 Your spec stays clean, your FastAPI code stays clean, but the UI reflects your preferences.
 There's a visual config GUI (npx @uigen-dev/cli config openapi.yaml) so you don't have to write YAML by hand. Point-and-click to hide endpoints, rename fields, and customize the theme.
 What Actually Works Now
 After building this app and fixing the gaps, here's what UIGen generates from my FastAPI spec:
  
Table views with sorting, pagination, and filtering (query params from the spec)
 Create/edit forms with validation matching my Pydantic models
 Detail views with related resource links (meetings → templates)
 File upload UI for template and recording uploads
 Custom action buttons - "Generate Documents", "Convert to PDF", "Download PDF"
 Full authentication cycle - login, signup, password reset, token storage, automatic header injection
 Vendor extensions - x-uigen-ignore, x-uigen-label, x-uigen-login for customization
 Config GUI - visual editor for annotations and theme customization
 Dark/light theme toggle
  
Try It Yourself
 The meeting minutes app is in the UIGen repo as a full example:
 ```bash git clone https://github.com/darula-hpp/uigen cd examples/apps/fastapi/meeting-minutes
 Start backend (FastAPI + PostgreSQL)
 docker compose up -d docker compose exec app alembic upgrade head
 Generate frontend
 cd ../../../ pnpm install && pnpm build npx @uigen-dev/cli serve examples/apps/fastapi/meeting-minutes/openapi.yaml ```
 Or try it on your own FastAPI app:
 bash npx @uigen-dev/cli serve http://localhost:8000/openapi.json 
 Limitations
 There are still gaps:
  
Circular references - Deeply nested recursive Pydantic models might skip the deepest levels
 Complex relationships - Many-to-many with extra fields on the join table needs manual handling
 Custom validation - Pydantic validators with custom logic don't translate to the frontend
 WebSockets - Not supported yet
 Streaming responses - Not supported
 GraphQL - OpenAPI/REST only for now
 Every OAuth variant - Works for Bearer/API Key/Basic, but not every custom auth flow
  
V1 will probably be suited for internal tools, admin panels, and rapid prototyping. Not a replacement for a polished consumer-facing app with custom UX requirements. But yeah, its an intereting challenge to include even more usecases.
 What's Next
 I'm trying to figure out: - Better relationship detection and easy relationship config. - A non bloat way to do layout customizations
 - Adding Polish & a non Bloat way to configure your app (App name etc)
 If you've built a FastAPI app and want to see what UIGen generates, I'd love feedback. The more real-world specs I test against, the better this gets.
 GitHub: https://github.com/darula-hpp/uigen
 npm: https://www.npmjs.com/package/@uigen-dev/cli
 Docs: https://uigen-docs.vercel.app
 Architecture: https://uigen-docs.vercel.app/blog/uigen-architecture
  
Happy to hear what you think.
    submitted by    /u/Prestigious-Bee2093  
 [link]   [comments]

I built UIGen to auto-generate React frontends from FastAPI OpenAPI specs - here's what happened when I used it on a real internal app

<div class="md">Hello all, I am a Jr Data Analyst in a MNC. Recently due to internal shifting, I have been assigned a FastAPI project which was earlier maintained by a Senior Developer. I am having a tough time understanding what&#39;s going on in the codebase ( in terms of the system). How do I tackle this issue? They expect me to start delivering within weeks or I will be sacked. Please help! </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/adamfloyd1506"> /u/adamfloyd1506 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1so6bxn/help_i_am_having_a_tough_time_understanding_the/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1so6bxn/help_i_am_having_a_tough_time_understanding_the/">[comments]</a>

Hello all,
 I am a Jr Data Analyst in a MNC.
 Recently due to internal shifting, I have been assigned a FastAPI project which was earlier maintained by a Senior Developer.
 I am having a tough time understanding what's going on in the codebase ( in terms of the system).
 How do I tackle this issue? They expect me to start delivering within weeks or I will be sacked.
 Please help!
    submitted by    /u/adamfloyd1506  
 [link]   [comments]

HELP! I am having a tough time understanding the codebase

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1spkrj7/fastapi_documentation_code_not_working/"> <img src="https://preview.redd.it/ex6d97rn83wg1.png?width=320&amp;crop=smart&amp;auto=webp&amp;s=5912f8d647aa8fb0672e106304eeac17a3119cdf" alt="FastAPI documentation code not working?" title="FastAPI documentation code not working?" /> </a> </td><td> <div class="md">(Solved) I am trying to recieve a list of files with my code, but I can only input strings of random characters when I try to test my method using the documentation page. The code works perfectly when I change it the a single UploadFile. Nothing I do seems to fix this, can someone please tell me what I am doing wrong? <pre><code>from fastapi import FastAPI, File, UploadFile, HTTPException from pathlib import Path from typing import List @app.post(&quot;/uploadfile/&quot;) def create_upload_file(files: List[UploadFile] = File(...)): </code></pre> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Brian1439"> /u/Brian1439 </a> <a href="https://i.redd.it/ex6d97rn83wg1.png">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1spkrj7/fastapi_documentation_code_not_working/">[comments]</a> </td></tr></table>

(Solved) 
 I am trying to recieve a list of files with my code, but I can only input strings of random characters when I try to test my method using the documentation page. The code works perfectly when I change it the a single UploadFile. Nothing I do seems to fix this, can someone please tell me what I am doing wrong?
 from fastapi import FastAPI, File, UploadFile, HTTPException from pathlib import Path from typing import List @app.post("/uploadfile/") def create_upload_file(files: List[UploadFile] = File(...)): 
    submitted by    /u/Brian1439  
 [link]   [comments]

FastAPI documentation code not working?

<div class="md">Hey. Long time Django dev here, I&#39;m planning on switching to fast API because of async. Probably a dumb question. I&#39;m trying to find a good out-of-the-box package for authentication, but it looks like fast API-users is pretty complicated with setting up JWT, refresh tokens etc. is there any more modern all-in-one package that handles all this out of the box? With oAuth2 as well etc? I heard of AuthX. Is that good? Any help would be appreciated. Thanks </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/No-Iron8430"> /u/No-Iron8430 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1st5gsq/best_way_to_set_up_authentication_out_of_the_box/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1st5gsq/best_way_to_set_up_authentication_out_of_the_box/">[comments]</a>

Hey. Long time Django dev here, I'm planning on switching to fast API because of async.
 Probably a dumb question. I'm trying to find a good out-of-the-box package for authentication, but it looks like fast API-users is pretty complicated with setting up JWT, refresh tokens etc. is there any more modern all-in-one package that handles all this out of the box? With oAuth2 as well etc? I heard of AuthX. Is that good? Any help would be appreciated. 
 Thanks
    submitted by    /u/No-Iron8430  
 [link]   [comments]

Best Way to set up authentication out of the box

<div class="md">I wrote here recently about my project and its evaluation, and I thank you all for the advice — it helped me a lot. I used it to build a new small project with simple authentication. It’s quite minimal, but I tried to do things the right way based on your suggestions. GitHub: <a href="https://github.com/Petr201317/fastapi_shop">https://github.com/Petr201317/fastapi_shop</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Proper-Development90"> /u/Proper-Development90 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sqej1m/looking_for_feedback_on_my_new_fastapi_project/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sqej1m/looking_for_feedback_on_my_new_fastapi_project/">[comments]</a>

I wrote here recently about my project and its evaluation, and I thank you all for the advice — it helped me a lot. I used it to build a new small project with simple authentication. It’s quite minimal, but I tried to do things the right way based on your suggestions.
 GitHub: https://github.com/Petr201317/fastapi_shop
    submitted by    /u/Proper-Development90  
 [link]   [comments]

Looking for feedback on my new fastapi project

<table> <tr><td> <a href="https://www.reddit.com/r/FastAPI/comments/1so6jau/fastchannels_and_chanx_the_missing_toolkit_for/"> <img src="https://external-preview.redd.it/II551CTOz56xvVYNJV5q5GXqVsHgRVFlPpRRCKp3upQ.png?width=140&amp;height=70&amp;auto=webp&amp;s=fe56228c47b69cd6cbb5f81dd87c059a9e78512c" alt="FastChannels and ChanX: The missing toolkit for WebSocket handling in FastAPI" title="FastChannels and ChanX: The missing toolkit for WebSocket handling in FastAPI" /> </a> </td><td> <div class="md">Hi everyone, I want to share with you both of my packages, which are mainly for improving FastAPI (and any ASGI-compatible library) when it comes to WebSocket handling. First, FastAPI&#39;s WebSocket handling is fairly simple with @app.websocket where you define the flow and run the loop (while True), but this can lead to some problems: <ul> <li>Harder to debug and separate code</li> <li>No way to broadcast messages. FastAPI&#39;s official guide uses a ConnectionManager as a simple class, but it is in-memory, fragile, and hard to scale</li> <li>FastAPI also mentions: &quot;If you need something easy to integrate with FastAPI but that is more robust, supported by Redis, PostgreSQL or others, check encode/broadcaster.&quot; However, broadcaster is no longer maintained as &quot;This repository was archived by the owner on Aug 19, 2025. It is now read-only.&quot; (unfortunate)</li> <li>No real way to send messages from another thread, a background job, or even an API endpoint without resorting to workarounds</li> </ul> Based on that, and with the knowledge I gained from Django Channels, I ported the Django Channels library to be fully FastAPI-compatible. The result is <a href="https://github.com/huynguyengl99/fast-channels">FastChannels</a>, which solves exactly the problems above. On top of that, when working with WebSocket (in both Django and FastAPI), my team and I usually face these problems: <ul> <li>Manual if-else routing chains when receiving a WebSocket message</li> <li>Manual validation of the messages we receive</li> <li>Runtime type surprises</li> <li>No source of truth for documentation (almost never seen, even though we have the AsyncAPI standard now)</li> <li>Testing that is painfully hard</li> <li>Painful code reviews and onboarding, since we need to scroll and read a lot to understand what messages are accepted, what the implementation does, and what gets returned</li> <li>No logging utility or standard like structlog for request and response tracing</li> </ul> Due to those problems, I created <a href="https://github.com/huynguyengl99/chanx">ChanX</a> as a library that improves the way we build WebSocket handling. Now, thanks to ChanX, we get: <ul> <li>No more endless if-else logic or 200-line functions that just route to the correct message handler. We simply define messages with the correct type, and thanks to Pydantic&#39;s type discriminator, they are automatically routed to the correct handler</li> <li>No more manual message validation, as Pydantic is the standard for defining both incoming and outgoing messages</li> <li>Type hints by default, with mypy and pyright support</li> <li>A testing framework included to make testing easier and more predictable</li> <li>And notably, auto-generated AsyncAPI documentation based on the code you define, similar to how FastAPI auto-generates OpenAPI docs from your code</li> <li>A CLI helper to generate code from AsyncAPI docs as well</li> </ul> So, here is how it looks <a href="https://preview.redd.it/3v9rtltg5svg1.png?width=1348&amp;format=png&amp;auto=webp&amp;s=c1dfecbbd58ae7040a3e58f8a85aeb73378c1c08">https://preview.redd.it/3v9rtltg5svg1.png?width=1348&amp;format=png&amp;auto=webp&amp;s=c1dfecbbd58ae7040a3e58f8a85aeb73378c1c08</a> I built ChanX based on what I have done, faced, and wished I had for my last project. I am using it now and I love it. I built it with careful design and active maintenance, so I hope you find it useful and never have to face these problems again. Some use cases where these work well: <ul> <li>Realtime messaging (one-on-one or group chat with broadcasting and notifications)</li> <li>Realtime voice assistants (e.g. Deepgram, OpenAI) or chat assistants with streaming responses</li> <li>Any scenario that involves group messaging, broadcasting, or push notifications over WebSocket</li> </ul> Here are the links related to FastChannels: <ul> <li>Github: <a href="https://github.com/huynguyengl99/fast-channels">https://github.com/huynguyengl99/fast-channels</a></li> <li>PyPI: <a href="https://pypi.org/project/fast-channels/">https://pypi.org/project/fast-channels/</a></li> <li>Documentation: <a href="https://fast-channels.readthedocs.io/en/latest/">https://fast-channels.readthedocs.io/en/latest/</a></li> <li>Tutorial for FastChannels: <a href="https://fast-channels.readthedocs.io/en/latest/tutorial/index.html">https://fast-channels.readthedocs.io/en/latest/tutorial/index.html</a></li> </ul> Here are the links related to ChanX: <ul> <li>Github: <a href="https://github.com/huynguyengl99/chanx">https://github.com/huynguyengl99/chanx</a></li> <li>PyPI: <a href="https://pypi.org/project/chanx">https://pypi.org/project/chanx</a></li> <li>Documentation: <a href="https://chanx.readthedocs.io/">https://chanx.readthedocs.io/</a></li> <li>Tutorial for newcomers: <a href="https://chanx.readthedocs.io/en/latest/tutorial-fastapi/prerequisites.html">https://chanx.readthedocs.io/en/latest/tutorial-fastapi/prerequisites.html</a></li> </ul> Hope you all find it useful. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/huygl99"> /u/huygl99 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1so6jau/fastchannels_and_chanx_the_missing_toolkit_for/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1so6jau/fastchannels_and_chanx_the_missing_toolkit_for/">[comments]</a> </td></tr></table>

Hi everyone, I want to share with you both of my packages, which are mainly for improving FastAPI (and any ASGI-compatible library) when it comes to WebSocket handling.
 First, FastAPI's WebSocket handling is fairly simple with @app.websocket where you define the flow and run the loop (while True), but this can lead to some problems:
  
Harder to debug and separate code
 No way to broadcast messages. FastAPI's official guide uses a ConnectionManager as a simple class, but it is in-memory, fragile, and hard to scale
 FastAPI also mentions: "If you need something easy to integrate with FastAPI but that is more robust, supported by Redis, PostgreSQL or others, check encode/broadcaster." However, broadcaster is no longer maintained as "This repository was archived by the owner on Aug 19, 2025. It is now read-only." (unfortunate)
 No real way to send messages from another thread, a background job, or even an API endpoint without resorting to workarounds
  
Based on that, and with the knowledge I gained from Django Channels, I ported the Django Channels library to be fully FastAPI-compatible. The result is FastChannels, which solves exactly the problems above.
 On top of that, when working with WebSocket (in both Django and FastAPI), my team and I usually face these problems:
  
Manual if-else routing chains when receiving a WebSocket message
 Manual validation of the messages we receive
 Runtime type surprises
 No source of truth for documentation (almost never seen, even though we have the AsyncAPI standard now)
 Testing that is painfully hard
 Painful code reviews and onboarding, since we need to scroll and read a lot to understand what messages are accepted, what the implementation does, and what gets returned
 No logging utility or standard like structlog for request and response tracing
  
Due to those problems, I created ChanX as a library that improves the way we build WebSocket handling. Now, thanks to ChanX, we get:
  
No more endless if-else logic or 200-line functions that just route to the correct message handler. We simply define messages with the correct type, and thanks to Pydantic's type discriminator, they are automatically routed to the correct handler
 No more manual message validation, as Pydantic is the standard for defining both incoming and outgoing messages
 Type hints by default, with mypy and pyright support
 A testing framework included to make testing easier and more predictable
 And notably, auto-generated AsyncAPI documentation based on the code you define, similar to how FastAPI auto-generates OpenAPI docs from your code
 A CLI helper to generate code from AsyncAPI docs as well
  
So, here is how it looks
 https://preview.redd.it/3v9rtltg5svg1.png?width=1348&format=png&auto=webp&s=c1dfecbbd58ae7040a3e58f8a85aeb73378c1c08
 I built ChanX based on what I have done, faced, and wished I had for my last project. I am using it now and I love it. I built it with careful design and active maintenance, so I hope you find it useful and never have to face these problems again.
 Some use cases where these work well:
  
Realtime messaging (one-on-one or group chat with broadcasting and notifications)
 Realtime voice assistants (e.g. Deepgram, OpenAI) or chat assistants with streaming responses
 Any scenario that involves group messaging, broadcasting, or push notifications over WebSocket
  
Here are the links related to FastChannels:
  
Github: https://github.com/huynguyengl99/fast-channels
 PyPI: https://pypi.org/project/fast-channels/
 Documentation: https://fast-channels.readthedocs.io/en/latest/
 Tutorial for FastChannels: https://fast-channels.readthedocs.io/en/latest/tutorial/index.html
  
Here are the links related to ChanX:
  
Github: https://github.com/huynguyengl99/chanx
 PyPI: https://pypi.org/project/chanx
 Documentation: https://chanx.readthedocs.io/
 Tutorial for newcomers: https://chanx.readthedocs.io/en/latest/tutorial-fastapi/prerequisites.html
  
Hope you all find it useful.
    submitted by    /u/huygl99  
 [link]   [comments]

FastChannels and ChanX: The missing toolkit for WebSocket handling in FastAPI

<div class="md">Hey everyone, I&#39;m learning FastAPI and I&#39;m building a file upload endpoint for audio files (WAV, MP3, FLAC, OGG). Here&#39;s what I have so far: - Filename sanitization + path traversal protection - Magic bytes validation (not just extension checking) - Chunked streaming write to avoid loading the whole file into memory - Size limit of 1GB checked incrementally during streaming - Early rejection via Content-Length header - Proper HTTP status codes (413, 415, 422...) Now I need to tackle two things and I&#39;d love some guidance: 1. Checksum validation I want to verify file integrity after upload — hash the file server-side during streaming (sha256) and compare it against a hash the client sends. But I&#39;m thinking from the user&#39;s perspective: the user should just curl the endpoint or click an upload button, nothing more. So how should the client send the hash without adding friction? Header? Something else? 2. Resumable uploads Same user-first thinking — if the network drops mid-upload, when it comes back the upload should continue from where it stopped, not restart. The user shouldn&#39;t have to do anything special, just upload like normal. How would you handle both of these in FastAPI? Any advice or resources appreciated! <pre><code>from fastapi import FastAPI, UploadFile, HTTPException, Request, File from fastapi.responses import FileResponse from pydantic import BaseModel from pathlib import Path import re from hashlib import HASH, sha256 import aiofiles UPLOAD_DIR = Path(&quot;uploads&quot;) UPLOAD_DIR.mkdir(exist_ok=True) MAGIC_BYTES = {b&#39;RIFF&#39;, b&#39;ID3\x00&#39;, b&#39;fLaC&#39;, b&#39;OggS&#39;} CHUNK_SIZE = 5 * 1024 * 1024 MAX_FILE_SIZE = 1 * 1024 * 1024 * 1024 class UploadResponse(BaseModel): filename: str size: int app = FastAPI(tags_metadata=[ { &quot;name&quot;: &quot;files&quot;, &quot;description&quot;: &quot;Operations related to audio file management&quot; } ]) def sanitize_filename(filename: str | None) -&gt; Path: if filename is None: raise HTTPException(status_code=422, detail=&quot;Filename is missing&quot;) filename = Path(filename).name filename = re.sub(r&quot;[^\w \- .]&quot;, &quot;_&quot;, filename) file_path = (UPLOAD_DIR / filename).resolve() if not file_path.is_relative_to(UPLOAD_DIR.resolve()): raise HTTPException(status_code=400, detail=&quot;Invalid filename&quot;) return file_path async def check_magic_bytes(file: UploadFile) -&gt; None: first_bytes = await file.read(4) if first_bytes not in MAGIC_BYTES: raise HTTPException(status_code=415, detail=&quot;Unsupported file type&quot;) await file.seek(0) def compare_checksum(file_path: Path, server_hash: HASH, client_hash: HASH) -&gt; None: if server_hash != client_hash: file_path.unlink() # delete the incomplete file raise HTTPException(status_code=400, detail=&quot;File corrupted&quot;) async def save_file(request: Request, file_path: Path, file: UploadFile) -&gt; None: hasher = sha256() file_size = 0 length = request.headers.get(&quot;content-length&quot;) if not length or int(length) &gt; MAX_FILE_SIZE: raise HTTPException(413, &quot;Max size is 1GB&quot;) async with aiofiles.open(file_path, &quot;wb&quot;) as f: while True: chunk = await file.read(CHUNK_SIZE) if not chunk: break file_size += len(chunk) if file_size &gt; MAX_FILE_SIZE: file_path.unlink() raise HTTPException(status_code=413) hasher.update(chunk) await f.write(chunk) u/app.post(&quot;/api/v4/upload&quot;, response_model=UploadResponse, summary=&quot;Upload an audio file&quot;, description=( &quot;Upload an audio file (WAV, MP3, FLAC, OGG). &quot; &quot;Max file size is 1GB. &quot; &quot;File type is validated via magic bytes, not extension.&quot; ), responses={ 200: {&quot;description&quot;: &quot;File uploaded successfully&quot;}, 400: {&quot;description&quot;: &quot;Path traversal attempt detected&quot;}, 413: {&quot;description&quot;: &quot;File exceeds the 1GB size limit&quot;}, 415: {&quot;description&quot;: &quot;Unsupported file type&quot;}, 422: {&quot;description&quot;: &quot;Filename is missing or invalid&quot;}, }, tags=[&quot;files&quot;] ) async def upload_file(request: Request, file: UploadFile = File(..., description=&quot;Audio file to upload (WAV, MP3, FLAC, OGG). Max 1GB.&quot;)): &quot;&quot;&quot; Upload an audio file to the server. - **file**: Audio file to upload (WAV, MP3, FLAC, OGG) - **Max size**: 1GB - **Validation**: magic bytes check, filename sanitization, path traversal protection &quot;&quot;&quot; file_path = sanitize_filename(file.filename) await check_magic_bytes(file) await save_file(request, file_path, file) return UploadResponse(filename= file.filename, size= file_path.stat().st_size) </code></pre> </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/1sr57nt/learning_fastapi_built_a_file_upload_endpoint/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sr57nt/learning_fastapi_built_a_file_upload_endpoint/">[comments]</a>

Hey everyone, I'm learning FastAPI and I'm building a file upload endpoint for audio files (WAV, MP3, FLAC, OGG).
 Here's what I have so far:
 - Filename sanitization + path traversal protection
 - Magic bytes validation (not just extension checking)
 - Chunked streaming write to avoid loading the whole file into memory
 - Size limit of 1GB checked incrementally during streaming
 - Early rejection via Content-Length header
 - Proper HTTP status codes (413, 415, 422...)
 Now I need to tackle two things and I'd love some guidance:
 1. Checksum validation
 I want to verify file integrity after upload — hash the file server-side during streaming (sha256) and compare it against a hash the client sends. But I'm thinking from the user's perspective: the user should just curl the endpoint or click an upload button, nothing more. So how should the client send the hash without adding friction? Header? Something else?
 2. Resumable uploads
 Same user-first thinking — if the network drops mid-upload, when it comes back the upload should continue from where it stopped, not restart. The user shouldn't have to do anything special, just upload like normal.
 How would you handle both of these in FastAPI? Any advice or resources appreciated!
 from fastapi import FastAPI, UploadFile, HTTPException, Request, File from fastapi.responses import FileResponse from pydantic import BaseModel from pathlib import Path import re from hashlib import HASH, sha256 import aiofiles UPLOAD_DIR = Path("uploads") UPLOAD_DIR.mkdir(exist_ok=True) MAGIC_BYTES = {b'RIFF', b'ID3\x00', b'fLaC', b'OggS'} CHUNK_SIZE = 5 * 1024 * 1024 MAX_FILE_SIZE = 1 * 1024 * 1024 * 1024 class UploadResponse(BaseModel): filename: str size: int app = FastAPI(tags_metadata=[ { "name": "files", "description": "Operations related to audio file management" } ]) def sanitize_filename(filename: str | None) -> Path: if filename is None: raise HTTPException(status_code=422, detail="Filename is missing") filename = Path(filename).name filename = re.sub(r"[^\w \- .]", "_", filename) file_path = (UPLOAD_DIR / filename).resolve() if not file_path.is_relative_to(UPLOAD_DIR.resolve()): raise HTTPException(status_code=400, detail="Invalid filename") return file_path async def check_magic_bytes(file: UploadFile) -> None: first_bytes = await file.read(4) if first_bytes not in MAGIC_BYTES: raise HTTPException(status_code=415, detail="Unsupported file type") await file.seek(0) def compare_checksum(file_path: Path, server_hash: HASH, client_hash: HASH) -> None: if server_hash != client_hash: file_path.unlink() # delete the incomplete file raise HTTPException(status_code=400, detail="File corrupted") async def save_file(request: Request, file_path: Path, file: UploadFile) -> None: hasher = sha256() file_size = 0 length = request.headers.get("content-length") if not length or int(length) > MAX_FILE_SIZE: raise HTTPException(413, "Max size is 1GB") async with aiofiles.open(file_path, "wb") as f: while True: chunk = await file.read(CHUNK_SIZE) if not chunk: break file_size += len(chunk) if file_size > MAX_FILE_SIZE: file_path.unlink() raise HTTPException(status_code=413) hasher.update(chunk) await f.write(chunk) u/app.post("/api/v4/upload", response_model=UploadResponse, summary="Upload an audio file", description=( "Upload an audio file (WAV, MP3, FLAC, OGG). " "Max file size is 1GB. " "File type is validated via magic bytes, not extension." ), responses={ 200: {"description": "File uploaded successfully"}, 400: {"description": "Path traversal attempt detected"}, 413: {"description": "File exceeds the 1GB size limit"}, 415: {"description": "Unsupported file type"}, 422: {"description": "Filename is missing or invalid"}, }, tags=["files"] ) async def upload_file(request: Request, file: UploadFile = File(..., description="Audio file to upload (WAV, MP3, FLAC, OGG). Max 1GB.")): """ Upload an audio file to the server. - **file**: Audio file to upload (WAV, MP3, FLAC, OGG) - **Max size**: 1GB - **Validation**: magic bytes check, filename sanitization, path traversal protection """ file_path = sanitize_filename(file.filename) await check_magic_bytes(file) await save_file(request, file_path, file) return UploadResponse(filename= file.filename, size= file_path.stat().st_size) 
    submitted by    /u/NiceSand6327  
 [link]   [comments]

Learning FastAPI — built a file upload endpoint, need advice on checksum and resumable uploads

<div class="md">Hi everyone, I’d really appreciate it if you could take a look at my code and give me some feedback. The functionality is fairly basic and not the main focus here — what I’m really interested in is evaluating the structure, organization, and overall code quality. I’m trying to improve my understanding of best practices, so any suggestions in that direction would be especially helpful. Feel free to point out anything that could be improved, whether it’s readability, naming conventions, modularity, or general design choices. Github: <a href="https://github.com/Petr201317/fastAPI_cinema">https://github.com/Petr201317/fastAPI_cinema</a> Thanks in advance for your time </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Proper-Development90"> /u/Proper-Development90 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sob44k/look_for_feedback_on_my_fastapi_project/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sob44k/look_for_feedback_on_my_fastapi_project/">[comments]</a>

Hi everyone,
 I’d really appreciate it if you could take a look at my code and give me some feedback. The functionality is fairly basic and not the main focus here — what I’m really interested in is evaluating the structure, organization, and overall code quality. I’m trying to improve my understanding of best practices, so any suggestions in that direction would be especially helpful. Feel free to point out anything that could be improved, whether it’s readability, naming conventions, modularity, or general design choices.
 Github: https://github.com/Petr201317/fastAPI_cinema
 Thanks in advance for your time
    submitted by    /u/Proper-Development90  
 [link]   [comments]

Look for feedback on my fastapi project

<div class="md">If you’ve been curious about running AI models locally but felt overwhelmed by GPU specs, Docker stacks, and unclear tutorials, you’re in the right place. In this guide, you’ll learn how to host small models using Ollama in local machine environments with a practical, step-by-step approach. We’ll cover setup, model selection, performance tuning, local API usage, and real-world use cases like support assistants and coding helpers. By the end, you’ll have a working local AI stack that is private, cost-effective, and easy to maintain. import requests url = &quot;http://localhost:11434/api/generate&quot; payload = { &quot;model&quot;: &quot;llama3.2:3b&quot;, &quot;prompt&quot;: &quot;Create a polite reply to a delayed shipment complaint.&quot;, &quot;stream&quot;: False } resp = requests.post(url, json=payload, timeout=60) resp.raise_for_status() print(resp.json()[&quot;response&quot;]) </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Worldly_Mammoth_7868"> /u/Worldly_Mammoth_7868 </a> <a href="https://codesips.com/blog/how-to-host-small-models-with-ollama-on-your-local-machine-beginner-to-production">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1st83f7/codesips_developer_cheat_sheets_agentic_ai/">[comments]</a>

If you’ve been curious about running AI models locally but felt overwhelmed by GPU specs, Docker stacks, and unclear tutorials, you’re in the right place. In this guide, you’ll learn how to host small models using Ollama in local machine environments with a practical, step-by-step approach. We’ll cover setup, model selection, performance tuning, local API usage, and real-world use cases like support assistants and coding helpers. By the end, you’ll have a working local AI stack that is private, cost-effective, and easy to maintain.
 import requests
 url = "http://localhost:11434/api/generate"
 payload = {
 "model": "llama3.2:3b",
 "prompt": "Create a polite reply to a delayed shipment complaint.",
 "stream": False
 }
 resp = requests.post(url, json=payload, timeout=60)
 resp.raise_for_status()
 print(resp.json()["response"])
    submitted by    /u/Worldly_Mammoth_7868  
 [link]   [comments]

codesips | Developer Cheat Sheets, Agentic AI & Solution Architecture Guides

<div class="md">I have worked on a project using FastAPI and python, a tool that; Analyze your project in seconds. <ul> <li>Stats: Lines of code, files, &amp; languages.</li> <li>AI: Intelligent file summaries via Groq.</li> <li>Clean: Detects unused functions/imports.</li> </ul> Repo: <a href="https://github.com/YounesBensafia/DevLens">https://github.com/YounesBensafia/DevLens</a> Install: <code>pip install devlens-tool</code> Stars appreciated! ⭐ </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/younesbensafia7"> /u/younesbensafia7 </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sprdnq/devlens_aipowered_codebase_analysis_dead_code/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sprdnq/devlens_aipowered_codebase_analysis_dead_code/">[comments]</a>

I have worked on a project using FastAPI and python, a tool that; 
 Analyze your project in seconds.
  
Stats: Lines of code, files, & languages.
 AI: Intelligent file summaries via Groq.
 Clean: Detects unused functions/imports.
  
Repo: https://github.com/YounesBensafia/DevLens 
 Install: pip install devlens-tool
 Stars appreciated! ⭐
    submitted by    /u/younesbensafia7  
 [link]   [comments]

DevLens: AI-powered codebase analysis & dead code detection

<div class="md">Just shipped a small project I&#39;m proud of: a Text Utility API built with FastAPI and HuggingFace Transformers. Endpoints: - /summarize - /sentiment - /keywords - /detect-language Used Pydantic for request validation, async handlers throughout, and it deploys cleanly on Render&#39;s free tier. Full source code available. Would love feedback from people who know FastAPI well — especially on structure and best practices. 🛠️ (link in comments) </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Pod3x"> /u/Pod3x </a> <a href="https://www.reddit.com/r/FastAPI/comments/1sqse08/built_a_4endpoint_text_utility_api_with_fastapi/">[link]</a> &#32; <a href="https://www.reddit.com/r/FastAPI/comments/1sqse08/built_a_4endpoint_text_utility_api_with_fastapi/">[comments]</a>

Just shipped a small project I'm proud of: a Text Utility API built with FastAPI and HuggingFace Transformers.
 Endpoints:
 - /summarize
 - /sentiment
 - /keywords
 - /detect-language
 Used Pydantic for request validation, async handlers throughout, and it deploys cleanly on Render's free tier. Full source code available.
 Would love feedback from people who know FastAPI well — especially on structure and best practices. 🛠️
 (link in comments)
    submitted by    /u/Pod3x  
 [link]   [comments]

Built a 4-endpoint Text Utility API with FastAPI + HuggingFace — feedback welcome

<div class="md">For the past few months I&#39;ve been using a flask app to serve static video to various devices on my home network(raspberry pi, tablet, etc.). I would like to deploy it publicly and want to make sure it&#39;s secure. I added a login with a werkzeug hashed password and will serve the app with waitress and nginx through a domain i got on porkbun. It&#39;s just for personal use/fun/learning. Is there anything else i should do for security purposes? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/OHMYDAYUMTHEYGOINHAM"> /u/OHMYDAYUMTHEYGOINHAM </a> <a href="https://www.reddit.com/r/flask/comments/1sp6vcu/first_time_deploying_a_flask_app_to_the_web/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1sp6vcu/first_time_deploying_a_flask_app_to_the_web/">[comments]</a>

For the past few months I've been using a flask app to serve static video to various devices on my home network(raspberry pi, tablet, etc.). I would like to deploy it publicly and want to make sure it's secure. I added a login with a werkzeug hashed password and will serve the app with waitress and nginx through a domain i got on porkbun. It's just for personal use/fun/learning. Is there anything else i should do for security purposes?
    submitted by    /u/OHMYDAYUMTHEYGOINHAM  
 [link]   [comments]

First time deploying a Flask app to the web.

<table> <tr><td> <a href="https://www.reddit.com/r/flask/comments/1sp84y6/flask_part_1_up_and_running/"> <img src="https://external-preview.redd.it/dEnk24xUC772opBswAtzefkjV8zUjBFTcQqe4F9AiDw.jpeg?width=320&amp;crop=smart&amp;auto=webp&amp;s=f181ade3c5370993e25f1c84f7722734f95a2fd5" alt="Flask Part 1 Up And Running" title="Flask Part 1 Up And Running" /> </a> </td><td> <div class="md">I walk through what Flask is, why it is such a popular framework, and how to get everything set up so you can begin developing right away. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Efficient-Public-551"> /u/Efficient-Public-551 </a> <a href="https://youtu.be/v9XQtYMXbNQ">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1sp84y6/flask_part_1_up_and_running/">[comments]</a> </td></tr></table>

I walk through what Flask is, why it is such a popular framework, and how to get everything set up so you can begin developing right away.
    submitted by    /u/Efficient-Public-551  
 [link]   [comments]

Flask Part 1 Up And Running

<table> <tr><td> <a href="https://www.reddit.com/r/flask/comments/1srhv4c/flask_jinja_templates_and_python_functions/"> <img src="https://external-preview.redd.it/RMvTQWteLLhsx4cOe_QGCOeVMbsAfQu1ME0zQj_91EE.jpeg?width=320&amp;crop=smart&amp;auto=webp&amp;s=0a801e23e8c88978ba721d8757d76a3e9ea44926" alt="Flask Jinja Templates And Python Functions" title="Flask Jinja Templates And Python Functions" /> </a> </td><td> <div class="md">In this video, I continue the Flask series by showing how to work with Jinja templates and Python functions to build dynamic pages the right way. I cover how Flask passes data from Python into HTML templates, how Jinja expressions and control structures work, and how to keep application logic in Python while using templates to render clean output. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Efficient-Public-551"> /u/Efficient-Public-551 </a> <a href="https://youtu.be/TBVVcrxFQgc">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1srhv4c/flask_jinja_templates_and_python_functions/">[comments]</a> </td></tr></table>

In this video, I continue the Flask series by showing how to work with Jinja templates and Python functions to build dynamic pages the right way. I cover how Flask passes data from Python into HTML templates, how Jinja expressions and control structures work, and how to keep application logic in Python while using templates to render clean output.
    submitted by    /u/Efficient-Public-551  
 [link]   [comments]

Flask Jinja Templates And Python Functions

<div class="md">I’ve been using Pydantic to validate forms and have a method to translate it to the database (different models with the same data). How does this compare to using something like flask-wtf? For context, here’s my repo (look at the recipes blueprint): <a href="https://github.com/ereaso/cookbook">https://github.com/ereaso/cookbook</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Informal-Chance-6067"> /u/Informal-Chance-6067 </a> <a href="https://www.reddit.com/r/flask/comments/1sp7sn0/wtforms_vs_pydantic_for_forms/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1sp7sn0/wtforms_vs_pydantic_for_forms/">[comments]</a>

I’ve been using Pydantic to validate forms and have a method to translate it to the database (different models with the same data). How does this compare to using something like flask-wtf? For context, here’s my repo (look at the recipes blueprint): https://github.com/ereaso/cookbook
    submitted by    /u/Informal-Chance-6067  
 [link]   [comments]

WTForms vs Pydantic for forms

<div class="md">I have a method/function the problem is sometimes I want to redirect to 1 route and sometimes I want to redirect to another different route. How do I accomplish this ? I can show the code if necessary. The only solution I can think of is inside the method/function is use a string in an if elif statements but I am wondering if there is a better way and if this is secure? ```py if x == &#39;redirect to route 1&#39; # redirect elif y == &#39;redirect to route 2&#39; # redirect ``` </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/0_emordnilap_a_ton"> /u/0_emordnilap_a_ton </a> <a href="https://www.reddit.com/r/flask/comments/1sqclpq/i_have_a_methodfunction_the_problem_is_sometimes/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1sqclpq/i_have_a_methodfunction_the_problem_is_sometimes/">[comments]</a>

I have a method/function the problem is sometimes I want to redirect to 1 route and sometimes I want to redirect to another different route. How do I accomplish this ? I can show the code if necessary. The only solution I can think of is inside the method/function is use a string
 in an if elif statements but I am wondering if there is a better way and if this is secure?
 ```py
 if x == 'redirect to route 1'
 # redirect
 elif y == 'redirect to route 2'
 # redirect
 ```
    submitted by    /u/0_emordnilap_a_ton  
 [link]   [comments]

I have a method/function the problem is sometimes I want to redirect to 1 route and sometimes I want to redirect to another different route. How do I accomplish this ?

<div class="md">I just released secure v2, a Python library for managing HTTP security headers without scattering policy across routes or app-specific hooks. For Flask, a simple pattern is: <pre><code>from flask import Flask from secure import Secure app = Flask(name) secure_headers = Secure.with_default_headers() @app.after_request def add_security_headers(response): secure_headers.set_headers(response) return response </code></pre> The goal is to keep header policy centralized, start from sane defaults, and apply it consistently across the app. Repo: <a href="https://github.com/TypeError/secure">https://github.com/TypeError/secure</a> Curious how others are handling security headers in Flask apps. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Nilvalues"> /u/Nilvalues </a> <a href="https://www.reddit.com/r/flask/comments/1stg62b/secure_v2_http_security_headers_for_flask_apps/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1stg62b/secure_v2_http_security_headers_for_flask_apps/">[comments]</a>

I just released secure v2, a Python library for managing HTTP security headers without scattering policy across routes or app-specific hooks.
 For Flask, a simple pattern is:
 from flask import Flask from secure import Secure app = Flask(name) secure_headers = Secure.with_default_headers() @app.after_request def add_security_headers(response): secure_headers.set_headers(response) return response 
 The goal is to keep header policy centralized, start from sane defaults, and apply it consistently across the app.
 Repo: https://github.com/TypeError/secure
 Curious how others are handling security headers in Flask apps.
    submitted by    /u/Nilvalues  
 [link]   [comments]

secure v2: HTTP security headers for Flask apps

<div class="md">So guys i want to learn flask for backend. Please suggest me from where should I start and if any playlist or project that I should make side by side. I saw yt tutorials but there they are teaching frontend. I don&#39;t want to learn it for frontend, I can use ai for that. So please help me </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Maleficent-Step2883"> /u/Maleficent-Step2883 </a> <a href="https://www.reddit.com/r/flask/comments/1sqjdol/help_me_what_to_learn/">[link]</a> &#32; <a href="https://www.reddit.com/r/flask/comments/1sqjdol/help_me_what_to_learn/">[comments]</a>

So guys i want to learn flask for backend. Please suggest me from where should I start and if any playlist or project that I should make side by side. I saw yt tutorials but there they are teaching frontend. I don't want to learn it for frontend, I can use ai for that. So please help me
    submitted by    /u/Maleficent-Step2883  
 [link]   [comments]

Help me what to learn ?

<div class="md">I made an ecommerce website using django and have run for 2years. At first time, I was quite afraid that t3.micro is not enough for my django backend server. However, these are what I experienced for 2years of running it.. specs are: backend : t3.micro / django5.0 / python 12 db : t3.micro / RDS PostgresQL cache : redis(elasticache) - I got about 20k~40k visitors a month, t3.micro backend server can handle even without any of cpu or memory spikes.. most of the time, cpu usage stays at 3~5%.. 10~15% for peak time.. - sometimes I got 50~70 concurrent users and t3.micro can handle without scale out and my app does not show any performance drop.. - no async, I use only restframework and still it is quite fast enough. page load takes 1.5sec, most of request takes 30~50ms. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/SnooCauliflowers8417"> /u/SnooCauliflowers8417 </a> <a href="https://www.reddit.com/r/django/comments/1squ1ws/django_application_with_t3micro_can_handle_a_lot/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1squ1ws/django_application_with_t3micro_can_handle_a_lot/">[comments]</a>

I made an ecommerce website using django and have run for 2years. At first time, I was quite afraid that t3.micro is not enough for my django backend server. However, these are what I experienced for 2years of running it..
 specs are:
 backend : t3.micro / django5.0 / python 12 
 db : t3.micro / RDS PostgresQL
 cache : redis(elasticache)
 - I got about 20k~40k visitors a month, t3.micro backend server can handle even without any of cpu or memory spikes.. most of the time, cpu usage stays at 3~5%.. 10~15% for peak time..
 - sometimes I got 50~70 concurrent users and t3.micro can handle without scale out and my app does not show any performance drop.. 
 - no async, I use only restframework and still it is quite fast enough. page load takes 1.5sec, most of request takes 30~50ms. 
    submitted by    /u/SnooCauliflowers8417  
 [link]   [comments]

django application with t3.micro can handle a lot of traffics..

<div class="md">We (team of 2 plus friends) have been building out DJForge – a starter kit for spinning up Django SaaS apps or startups fast. Up to now we have used it in a few projects and for some PoCs Key Features: <ul> <li>Modern Django Setup: Python 3.14+, managed with Astral&#39;s uv</li> <li>Styling: Tailwind CSS + daisyUI</li> <li>DB &amp; Services: Postgres (Docker Compose ready), PgAdmin for easy debugging</li> <li>Dev Tools: Ruff formatter/linter, LiveReload for CSS/HTML hot-reloading, optional tmux workflows</li> <li>Editors: Pre-configured .idea (PyCharm CE) and .vscode folders</li> <li>Deploy: One-click to Render, favicon generator links, HeroIcons throughout</li> <li>Extras: Landwind-inspired landing page</li> <li>Integrated <a href="http://react.email">react.email</a> for quick HTML email generation</li> </ul> Targeting agencies, freelancers, or solo devs wanting a SaaS base without reinventing the wheel. LLM-friendly code structure guiding your AI assistants towards clean Django patterns. Licensing: <ul> <li>Personal/hobby use: Free!</li> <li>Commercial/SaaS/templates: Symbolic $20 one-off. Alternatively: contribution to approximately half day of work. Aiming to keep the project sustainable without free-riding.</li> </ul> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/dimitrym"> /u/dimitrym </a> <a href="https://github.com/dimitrismistriotis/djforge">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1ssi7a7/djforge_productionready_django_saas_boilerplate/">[comments]</a>

We (team of 2 plus friends) have been building out DJForge – a starter kit for spinning up Django SaaS apps or startups fast. Up to now we have used it in a few projects and for some PoCs
 Key Features:
  
Modern Django Setup: Python 3.14+, managed with Astral's uv
 Styling: Tailwind CSS + daisyUI
 DB & Services: Postgres (Docker Compose ready), PgAdmin for easy debugging
 Dev Tools: Ruff formatter/linter, LiveReload for CSS/HTML hot-reloading, optional tmux workflows
 Editors: Pre-configured .idea (PyCharm CE) and .vscode folders
 Deploy: One-click to Render, favicon generator links, HeroIcons throughout
 Extras: Landwind-inspired landing page
 Integrated react.email for quick HTML email generation
  
Targeting agencies, freelancers, or solo devs wanting a SaaS base without reinventing the wheel. LLM-friendly code structure guiding your AI assistants towards clean Django patterns.
 Licensing:
  
Personal/hobby use: Free!
 Commercial/SaaS/templates: Symbolic $20 one-off. Alternatively: contribution to approximately half day of work. Aiming to keep the project sustainable without free-riding.
  
   submitted by    /u/dimitrym  
 [link]   [comments]

DJForge: Production-Ready Django SaaS Boilerplate – Tailwind + daisyUI, Postgres, uv, Ruff

<div class="md">A common pattern I&#39;ve seen across teams: a task gets queued, something silently fails on the publishing side, and the debugging session starts with no traces and no clear recovery process. After running into these issues repeatedly, I mapped out six stages of reliability for Celery/RabbitMQ setups: <ol> <li>Best Effort: fire-and-forget, at-most-once delivery, tasks can vanish silently</li> <li>Transactional Boundary: wrapping commands in atomic transactions to prevent out-of-sync data</li> <li>Publishing on Commit: using <code>delay_on_commit</code> so tasks aren&#39;t queued before the transaction succeeds</li> <li>Publisher Confirms: getting actual confirmation that the broker received and persisted the message</li> <li>Outbox Pattern: persisting intent to the database first, dispatching later, giving you at-least-once delivery</li> <li>Clusters and Quorum Queues: replication strategies and where classic queues can still lose messages</li> </ol> Full write-up here if useful: <a href="https://vladogir.substack.com/p/your-background-tasks-are-silently?r=157avd">https://vladogir.substack.com/p/your-background-tasks-are-silently?r=157avd</a> Next, I plan to cover the consumer side: idempotency, monitoring and observability. What do you think I missed? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Fragrant_Brush_4161"> /u/Fragrant_Brush_4161 </a> <a href="https://www.reddit.com/r/django/comments/1sp6hh9/most_celery_tutorials_cover_the_basics_but_they/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sp6hh9/most_celery_tutorials_cover_the_basics_but_they/">[comments]</a>

A common pattern I've seen across teams: a task gets queued, something silently fails on the publishing side, and the debugging session starts with no traces and no clear recovery process.
 After running into these issues repeatedly, I mapped out six stages of reliability for Celery/RabbitMQ setups:
  
Best Effort: fire-and-forget, at-most-once delivery, tasks can vanish silently
 Transactional Boundary: wrapping commands in atomic transactions to prevent out-of-sync data
 Publishing on Commit: using delay_on_commit so tasks aren't queued before the transaction succeeds
 Publisher Confirms: getting actual confirmation that the broker received and persisted the message
 Outbox Pattern: persisting intent to the database first, dispatching later, giving you at-least-once delivery
 Clusters and Quorum Queues: replication strategies and where classic queues can still lose messages
  
Full write-up here if useful: https://vladogir.substack.com/p/your-background-tasks-are-silently?r=157avd
 Next, I plan to cover the consumer side: idempotency, monitoring and observability.
 What do you think I missed?
    submitted by    /u/Fragrant_Brush_4161  
 [link]   [comments]

Most Celery tutorials cover the basics, but they rarely mention what can go wrong when publishing a message.

&#32; submitted by &#32; <a href="https://www.reddit.com/user/usmanhalalit"> /u/usmanhalalit </a> <a href="https://usman.it/django-realtime-updates-without-websockets/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sqqspi/django_to_browser_push_without_websockets/">[comments]</a>

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

Django to Browser Push - Without WebSockets, Channels, or Redis

<div class="md">I’ve been learning backend development and currently focusing on Django. But I keep seeing mixed opinions about it in the job market. Some say it’s still widely used and good for getting jobs, while others suggest that Node.js or other frameworks are more in demand nowadays. So I wanted to ask: <ul> <li>Is Django still a good choice for entering the backend job market today?</li> <li>What types of companies usually hire Django developers?</li> <li>Should a beginner stick with Django or switch to something like Node.js?</li> </ul> Would appreciate real-world insights from developers working in the industry 🙏 </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/1spn3da/is_django_still_a_good_choice/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1spn3da/is_django_still_a_good_choice/">[comments]</a>

I’ve been learning backend development and currently focusing on Django.
 But I keep seeing mixed opinions about it in the job market.
 Some say it’s still widely used and good for getting jobs, while others suggest that Node.js or other frameworks are more in demand nowadays.
 So I wanted to ask:
  
Is Django still a good choice for entering the backend job market today?
 What types of companies usually hire Django developers?
 Should a beginner stick with Django or switch to something like Node.js?
  
Would appreciate real-world insights from developers working in the industry 🙏
    submitted by    /u/Om_JR  
 [link]   [comments]

Is Django still a good choice?

<div class="md">Django was actually the first framework I properly learned, but I never really ended up deploying projects with it. I&#39;m looking at it again now and wanted to get a feel for what people actually use for small Django apps these days. Main thing I want is to keep it simple. Managed Postgres, Github Deploys, decent docs, and idealy no Docker setup just to get something live. Heroku used to feel like the default answer until they removed the free tier. I&#39;m curious what people prefer now? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Fit-Jello-4828"> /u/Fit-Jello-4828 </a> <a href="https://www.reddit.com/r/django/comments/1sry6hp/what_are_people_using_for_simple_django_hosting/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sry6hp/what_are_people_using_for_simple_django_hosting/">[comments]</a>

Django was actually the first framework I properly learned, but I never really ended up deploying projects with it. 
 I'm looking at it again now and wanted to get a feel for what people actually use for small Django apps these days.
 Main thing I want is to keep it simple. Managed Postgres, Github Deploys, decent docs, and idealy no Docker setup just to get something live. 
 Heroku used to feel like the default answer until they removed the free tier. I'm curious what people prefer now?
    submitted by    /u/Fit-Jello-4828  
 [link]   [comments]

What are people using for simple Django hosting these days?

&#32; submitted by &#32; <a href="https://www.reddit.com/user/dwaxe"> /u/dwaxe </a> <a href="https://www.djangoproject.com/weblog/2026/apr/16/pycharm-django-annual-fundraiser/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1snbk50/pycharm_django_annual_fundraiser/">[comments]</a>

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

PyCharm & Django annual fundraiser

<div class="md">Hi! A bit of self promotion. Folks on this reddit are asking from time to time about django architecture. I use a variant of original HackSoft styleguide with some modern async flavors: <a href="https://github.com/pySilver/django-styleguide">https://github.com/pySilver/django-styleguide</a> I don&#39;t chase github stars so if you have any negative emotions regarding this post - simply ignore it. P.s. I will be updating the styleguide to migrate from `<a href="https://django-ninja.dev">django-ninja</a>` to `<a href="https://github.com/wemake-services/django-modern-rest">django-modern-rest</a>` soon. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/silveroff"> /u/silveroff </a> <a href="https://www.reddit.com/r/django/comments/1spbsvt/django_styleguide/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1spbsvt/django_styleguide/">[comments]</a>

Hi! A bit of self promotion. Folks on this reddit are asking from time to time about django architecture. I use a variant of original HackSoft styleguide with some modern async flavors: https://github.com/pySilver/django-styleguide
 I don't chase github stars so if you have any negative emotions regarding this post - simply ignore it.
 P.s. I will be updating the styleguide to migrate from `django-ninja` to `django-modern-rest` soon.
    submitted by    /u/silveroff  
 [link]   [comments]

Django Styleguide

<div class="md">Hi everyone, I want to re-introduce my package <a href="https://github.com/huynguyengl99/chanx">ChanX</a>, an extension for Django Channels that makes WebSocket and realtime app development and maintenance much easier. As a developer who has been heavily working on realtime applications (group messaging, realtime voice handling with Deepgram integration, AI assistant chat), I always wished there was a package that could extend Django Channels to provide: <ul> <li>Easier WebSocket (chat/data) handling without if-else hell</li> <li>Type safety that works with mypy and pyright to catch errors before writing tests or going live in production</li> <li>Auto-documentation with AsyncAPI-compatible docs autogenerated from code, similar to how drf-spectacular generates OpenAPI from DRF serializers</li> <li>Testing utilities that make testing flows predictable and correct</li> <li>Logging helpers, like django-structlog, to trace what was received and what was sent in a message handling flow</li> <li>Even a command line tool to generate code from the generated docs (e.g. for other microservices to use)</li> </ul> And if you have ever used Django Channels to handle WebSocket/realtime messaging, I think you have likely run into these same problems: <ul> <li>Inconsistent implementations between consumers: some use if-else, some use match-case, resulting in messy logic</li> <li>Painful code reviews, since you cannot tell when something will respond or what it accepts without carefully reading through the full code end to end</li> <li>Slow onboarding and slow integration with other teams (e.g. frontend) due to the lack of any documentation or API contract (AsyncAPI docs are very helpful here)</li> <li>Testing that is hard and unpredictable, since the default testing in Django Channels is based on timing or the first response, but sometimes we need more</li> <li>Difficulty tracing how and where the code runs</li> </ul> So I built ChanX based on what I have done, faced, and wished I had for my last project. I am using it now and I love it. I built it with careful design and active maintenance, so I hope you find it useful and never have to face these problems again. Some use cases where ChanX works well: <ul> <li>Realtime messaging (one-on-one or group chat with broadcasting and notifications)</li> <li>Realtime voice assistants (e.g. Deepgram, OpenAI) or chat assistants with streaming responses</li> <li>Any scenario that involves group messaging, broadcasting, or push notifications over WebSocket</li> </ul> Also, some people have suggested using SSE rather than WebSocket when working with Django. I think in simple cases that would be fine, but I prefer the WebSocket/Channels approach because we get proper async handling and proper documentation (AsyncAPI). Here are the links for my package: <ul> <li>Github: <a href="https://github.com/huynguyengl99/chanx">https://github.com/huynguyengl99/chanx</a></li> <li>PyPI: <a href="https://pypi.org/project/chanx">https://pypi.org/project/chanx</a></li> <li>Documentation: <a href="https://chanx.readthedocs.io/">https://chanx.readthedocs.io/</a></li> <li>Tutorial for newcomers: <a href="https://chanx.readthedocs.io/en/latest/tutorial-django/prerequisites.html">https://chanx.readthedocs.io/en/latest/tutorial-django/prerequisites.html</a></li> </ul> Hope you all find it useful. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/huygl99"> /u/huygl99 </a> <a href="https://www.reddit.com/r/django/comments/1so5ggu/chanx_an_extension_library_for_django_channels/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1so5ggu/chanx_an_extension_library_for_django_channels/">[comments]</a>

Hi everyone, I want to re-introduce my package ChanX, an extension for Django Channels that makes WebSocket and realtime app development and maintenance much easier.
 As a developer who has been heavily working on realtime applications (group messaging, realtime voice handling with Deepgram integration, AI assistant chat), I always wished there was a package that could extend Django Channels to provide:
  
Easier WebSocket (chat/data) handling without if-else hell
 Type safety that works with mypy and pyright to catch errors before writing tests or going live in production
 Auto-documentation with AsyncAPI-compatible docs autogenerated from code, similar to how drf-spectacular generates OpenAPI from DRF serializers
 Testing utilities that make testing flows predictable and correct
 Logging helpers, like django-structlog, to trace what was received and what was sent in a message handling flow
 Even a command line tool to generate code from the generated docs (e.g. for other microservices to use)
  
And if you have ever used Django Channels to handle WebSocket/realtime messaging, I think you have likely run into these same problems:
  
Inconsistent implementations between consumers: some use if-else, some use match-case, resulting in messy logic
 Painful code reviews, since you cannot tell when something will respond or what it accepts without carefully reading through the full code end to end
 Slow onboarding and slow integration with other teams (e.g. frontend) due to the lack of any documentation or API contract (AsyncAPI docs are very helpful here)
 Testing that is hard and unpredictable, since the default testing in Django Channels is based on timing or the first response, but sometimes we need more
 Difficulty tracing how and where the code runs
  
So I built ChanX based on what I have done, faced, and wished I had for my last project. I am using it now and I love it. I built it with careful design and active maintenance, so I hope you find it useful and never have to face these problems again.
 Some use cases where ChanX works well:
  
Realtime messaging (one-on-one or group chat with broadcasting and notifications)
 Realtime voice assistants (e.g. Deepgram, OpenAI) or chat assistants with streaming responses
 Any scenario that involves group messaging, broadcasting, or push notifications over WebSocket
  
Also, some people have suggested using SSE rather than WebSocket when working with Django. I think in simple cases that would be fine, but I prefer the WebSocket/Channels approach because we get proper async handling and proper documentation (AsyncAPI).
 Here are the links for my package:
  
Github: https://github.com/huynguyengl99/chanx
 PyPI: https://pypi.org/project/chanx
 Documentation: https://chanx.readthedocs.io/
 Tutorial for newcomers: https://chanx.readthedocs.io/en/latest/tutorial-django/prerequisites.html
  
Hope you all find it useful.
    submitted by    /u/huygl99  
 [link]   [comments]

ChanX: An extension library for Django Channels that makes building realtime applications a breeze

&#32; submitted by &#32; <a href="https://www.reddit.com/user/jsheffi"> /u/jsheffi </a> <a href="https://jeffield.net/blog/your-models-know-their-own-schema-let-them-show-you/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1srpzho/your_models_know_their_own_schema_let_them_show/">[comments]</a>

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

Your Models Know Their Own Schema. Let Them Show You.

<div class="md">What do you think? What’s missing ORM you tried with it? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Commercial_Try_2538"> /u/Commercial_Try_2538 </a> <a href="https://www.reddit.com/r/django/comments/1srn2e8/anyone_with_django_6_ninja/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1srn2e8/anyone_with_django_6_ninja/">[comments]</a>

What do you think? What’s missing ORM you tried with it?
    submitted by    /u/Commercial_Try_2538  
 [link]   [comments]

Anyone with Django 6 + Ninja

&#32; submitted by &#32; <a href="https://www.reddit.com/user/dwaxe"> /u/dwaxe </a> <a href="https://www.djangoproject.com/weblog/2026/apr/19/dsf-member-of-the-month-rob-hudson/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1spzcmc/dsf_member_of_the_month_rob_hudson/">[comments]</a>

DSF member of the month - Rob Hudson

<div class="md">I just finished a Django project by vibe coding – but not with Cursor. I pasted everything into files manually, line by line. So I actually understand the basics and how everything fits together. Project features: <ul> <li>Login / Signup</li> <li>Examination page</li> <li>Custom admin panel with tabs for dashboard, exam config, key sessions, student records, and question CRUD (multiple choice, true/false, abstract reasoning)</li> </ul> Stack: Bootstrap + SQLite The client wants it fast, and I also want to learn Django more deeply. My questions: <ol> <li>How much should I charge for this (Philippines rates)?</li> <li>What should I learn next to level up from beginner to intermediate? Specific topics, projects, or resources would help a lot. Also – how do you actually learn them effectively?</li> </ol> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/CEENNNNNN"> /u/CEENNNNNN </a> <a href="https://www.reddit.com/r/django/comments/1sptzum/built_a_django_app_for_a_client_no_idea_how_much/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sptzum/built_a_django_app_for_a_client_no_idea_how_much/">[comments]</a>

I just finished a Django project by vibe coding – but not with Cursor. I pasted everything into files manually, line by line. So I actually understand the basics and how everything fits together.
 Project features:
  
Login / Signup
 Examination page
 Custom admin panel with tabs for dashboard, exam config, key sessions, student records, and question CRUD (multiple choice, true/false, abstract reasoning)
  
Stack: Bootstrap + SQLite
 The client wants it fast, and I also want to learn Django more deeply.
 My questions:
  
How much should I charge for this (Philippines rates)?
 What should I learn next to level up from beginner to intermediate? Specific topics, projects, or resources would help a lot. Also – how do you actually learn them effectively?
  
   submitted by    /u/CEENNNNNN  
 [link]   [comments]

Built a Django app for a client – no idea how much to charge. Need pricing advice.

&#32; submitted by &#32; <a href="https://www.reddit.com/user/dwaxe"> /u/dwaxe </a> <a href="https://www.djangoproject.com/weblog/2026/apr/16/new-technical-governance-request-for-community-fee/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1snet4r/new_technical_governance_request_for_community/">[comments]</a>

New Technical Governance - request for community feedback

<div class="md">I have been build a web application using django as backend server and postgres Sql. I haven&#39;t hosted my server on AWS both I am testing it locally and in my opinion it is taking 1.5 sec to go from one route to another. How should I optimize my django server for better response </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Old-Raspberry-3266"> /u/Old-Raspberry-3266 </a> <a href="https://www.reddit.com/r/django/comments/1srh6kn/why_is_my_django_server_slow/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1srh6kn/why_is_my_django_server_slow/">[comments]</a>

I have been build a web application using django as backend server and postgres Sql. I haven't hosted my server on AWS both I am testing it locally and in my opinion it is taking 1.5 sec to go from one route to another. How should I optimize my django server for better response 
    submitted by    /u/Old-Raspberry-3266  
 [link]   [comments]

Why is my Django server slow

<div class="md">I built this productivity app in django + vue.js &amp; hosted on vps with nginx as reverse proxy. I&#39;m using celery - for auto moving incomplete task to next &amp; other periodic tasks. django channels - publishing tasks updates back to vue.js frontend fernet - for encrypting tasks resend - for emails ( provides a generous free tier ) uvicorn - async server postgres - database hosted on <a href="https://lazyplanner.app">https://lazyplanner.app</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Secure-Composer-9458"> /u/Secure-Composer-9458 </a> <a href="https://www.reddit.com/gallery/1sphlpr">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sphlpr/built_this_task_aggregator_web_app_in_django/">[comments]</a>

I built this productivity app in django + vue.js & hosted on vps with nginx as reverse proxy.
 I'm using
 celery - for auto moving incomplete task to next & other periodic tasks.
 django channels - publishing tasks updates back to vue.js frontend
 fernet - for encrypting tasks
 resend - for emails ( provides a generous free tier )
 uvicorn - async server
 postgres - database
 hosted on https://lazyplanner.app 
    submitted by    /u/Secure-Composer-9458  
 [link]   [comments]

Built this task aggregator web app in Django + Vue.js. it fetches tasks from different platforms you use & also use AI to reschedule tasks or assign tags + other metadata to tasks.

<div class="md">I just shipped ArchUnitPython, a library that lets you enforce architectural rules in Python projects through automated tests. The problem it solves: as codebases grow, architecture erodes. Someone imports the database layer from the presentation layer, circular dependencies creep in, naming conventions drift. Code review catches some of it, but not all, and definitely not consistently. This problem has always existed but is more important than ever in Claude Code, Codex times. LLMs break architectural rules all the time. So I built a library where you define your architecture rules as tests. Two quick examples: ```python <h1>No circular dependencies in services</h1> rule = project_files(&quot;src/&quot;).in_folder(&quot;/services/&quot;).should().have_no_cycles() assert_passes(rule) ``` ```python <h1>Presentation layer must not depend on database layer</h1> rule = project_files(&quot;src/&quot;) .in_folder(&quot;/presentation/&quot;) .should_not() .depend_on_files() .in_folder(&quot;/database/&quot;) assert_passes(rule) ``` This will run in pytest, unittest, or whatever you use, and therefore be automatically in your CI/CD. If a commit violates the architecture rules your team has decided, the CI will fail. Hint: this is exactly what the famous ArchUnit Java library does, just for Python - I took inspiration for the name is of course. Let me quickly address why this over linters or generic code analysis? Linters catch style issues. This catches structural violations — wrong dependency directions, layering breaches, naming convention drift. It&#39;s the difference between &quot;this line looks wrong&quot; and &quot;this module shouldn&#39;t talk to that module.&quot; Some key features: <ul> <li>Dependency direction enforcement &amp; circular dependency detection</li> <li>Naming convention checks (glob + regex)</li> <li>Code metrics: LCOM cohesion, abstractness, instability, distance from main sequence</li> <li>PlantUML diagram validation — ensure code matches your architecture diagrams</li> <li>Custom rules &amp; metrics</li> <li>Zero runtime dependencies, uses only Python&#39;s ast module</li> <li>Python 3.10+</li> </ul> Very curious what you think! <a href="https://github.com/LukasNiessen/ArchUnitPython">https://github.com/LukasNiessen/ArchUnitPython</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/trolleid"> /u/trolleid </a> <a href="https://github.com/LukasNiessen/ArchUnitPython">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sn4sfr/i_built_archunit_for_python_enforce_architecture/">[comments]</a>

<div class="md">I’ve been building a platform where developers can find people to build projects with. We’re around 180 users now, and a couple of teams are actually active and shipping stuff, which is honestly the only metric I care about. Recently I added something new. Every week there’s a coding challenge. I post a problem (usually algo or backend-related), you solve it and publish your solution. Other devs can upvote or downvote it. At the end of the week, the top 3 solutions (based on votes) get the most points. Everyone who participates still earns something. Points are already withdrawable. It’s not huge money or anything, but it’s real, and it makes it a bit more fun to actually participate instead of just lurking. There are also open weekly projects you can join instantly. No applications, no waiting. Just jump in and start building with others. The goal is to keep things short so projects don’t die after a few days. Other stuff on the platform: you can create your own projects, get matched with people based on your stack, chat with your team, use a live code editor, do meetings with screen sharing, and there’s a public ranking as well. The whole idea is to remove friction. Most places are full of ideas but nothing actually gets built. If you want to try it or just see how it works: <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/1stfqzb/solve_coding_challenges_get_upvoted_earn_points/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1stfqzb/solve_coding_challenges_get_upvoted_earn_points/">[comments]</a>

I’ve been building a platform where developers can find people to build projects with. We’re around 180 users now, and a couple of teams are actually active and shipping stuff, which is honestly the only metric I care about.
 Recently I added something new.
 Every week there’s a coding challenge. I post a problem (usually algo or backend-related), you solve it and publish your solution. Other devs can upvote or downvote it.
 At the end of the week, the top 3 solutions (based on votes) get the most points. Everyone who participates still earns something.
 Points are already withdrawable. It’s not huge money or anything, but it’s real, and it makes it a bit more fun to actually participate instead of just lurking.
 There are also open weekly projects you can join instantly. No applications, no waiting. Just jump in and start building with others. The goal is to keep things short so projects don’t die after a few days.
 Other stuff on the platform: you can create your own projects, get matched with people based on your stack, chat with your team, use a live code editor, do meetings with screen sharing, and there’s a public ranking as well.
 The whole idea is to remove friction. Most places are full of ideas but nothing actually gets built.
 If you want to try it or just see how it works: https://www.codekhub.it/
    submitted by    /u/Heavy_Association633  
 [link]   [comments]

Solve coding challenges, get upvoted, earn points (and build with other devs)

<div class="md">Just released DjangoMOO 1.0.0 — a LambdaMOO-inspired MOO server built on Django. A MOO is a persistent online text world where objects have properties and verbs (Python methods) that players can write and modify in-world. Verb code runs in a RestrictedPython sandbox. The interesting Django angle: the object inheritance graph is a ManyToManyField, the admin exposes the entire world for editing, and each player command dispatches a Celery task. Posted a longer write-up on the Django Forum if you want the full architectural breakdown. Django Forum: <a href="https://forum.djangoproject.com/t/djangomoo-1-0-0-a-moo-server-built-on-django/44939">https://forum.djangoproject.com/t/djangomoo-1-0-0-a-moo-server-built-on-django/44939</a> GitLab: <a href="https://gitlab.com/bubblehouse/django-moo">https://gitlab.com/bubblehouse/django-moo</a> Docs: <a href="https://django-moo.readthedocs.io/">https://django-moo.readthedocs.io/</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/philchristensennyc"> /u/philchristensennyc </a> <a href="https://www.reddit.com/gallery/1spvu3i">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1spvu3i/djangomoo_100_i_built_a_moo_server_on_django_with/">[comments]</a>

Just released DjangoMOO 1.0.0 — a LambdaMOO-inspired MOO server built on Django. A MOO is a persistent online text world where objects have properties and verbs (Python methods) that players can write and modify in-world. Verb code runs in a RestrictedPython sandbox.
 The interesting Django angle: the object inheritance graph is a ManyToManyField, the admin exposes the entire world for editing, and each player command dispatches a Celery task. Posted a longer write-up on the Django Forum if you want the full architectural breakdown.
 Django Forum: https://forum.djangoproject.com/t/djangomoo-1-0-0-a-moo-server-built-on-django/44939
 GitLab: https://gitlab.com/bubblehouse/django-moo
 Docs: https://django-moo.readthedocs.io/
    submitted by    /u/philchristensennyc  
 [link]   [comments]

DjangoMOO 1.0.0 — I built a MOO server on Django (with a RestrictedPython verb sandbox)

<div class="md">I am asking about hostinger django vps reference: <a href="https://www.hostinger.com/vps/django-hosting">https://www.hostinger.com/vps/django-hosting</a> I would like to know what do you think of this one? I guess I would be able to host my PostgreSQL DB and Vue.js frontend on the same VPS , correct ? it&#39;s just a VPS prepared for django but I can add more , correct? like the vue.js frontend and the postgresql database also, for 200-500 users for a simple management app for my business do I have to worry about the bandwidth/ram ..etc or just pick the least option fine? 1 vCPU core 4 GB RAM 50 GB NVMe disk space 4 TB bandwidth --- one more thing, what do you guys do if you would like to host on the clients account without revealing your codebase? is that doable in case of web apps? </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/1ssiu4b/quick_question_hostinger_django_hosting/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1ssiu4b/quick_question_hostinger_django_hosting/">[comments]</a>

I am asking about hostinger django vps
 reference: https://www.hostinger.com/vps/django-hosting
 I would like to know what do you think of this one?
 I guess I would be able to host my PostgreSQL DB and Vue.js frontend on the same VPS , correct ? 
 it's just a VPS prepared for django but I can add more , correct?
 like the vue.js frontend and the postgresql database
 also, for 200-500 users for a simple management app for my business do I have to worry about the bandwidth/ram ..etc or just pick the least option fine?
 1 vCPU core
 4 GB RAM
 50 GB NVMe disk space
 4 TB bandwidth
 ---
 one more thing, what do you guys do if you would like to host on the clients account without revealing your codebase? is that doable in case of web apps?
    submitted by    /u/_khi4  
 [link]   [comments]

Quick Question: Hostinger Django Hosting

<div class="md">I’ve been considering using it, but lately they seem much quieter than before when it comes to marketing and general online presence, at least from what I’ve noticed. Sometimes that can mean a company is just focused on product, other times it can be a warning sign. For anyone using Appliku recently, how has your experience been? Is it still dependable, is support responsive, and would you still choose it today over other options? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/IWBN"> /u/IWBN </a> <a href="https://www.reddit.com/r/django/comments/1ss5qtc/is_appliku_still_reliable/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1ss5qtc/is_appliku_still_reliable/">[comments]</a>

I’ve been considering using it, but lately they seem much quieter than before when it comes to marketing and general online presence, at least from what I’ve noticed. Sometimes that can mean a company is just focused on product, other times it can be a warning sign.
 For anyone using Appliku recently, how has your experience been? Is it still dependable, is support responsive, and would you still choose it today over other options?
    submitted by    /u/IWBN  
 [link]   [comments]

Is appliku still reliable?

&#32; submitted by &#32; <a href="https://www.reddit.com/user/AffectionateWar5927"> /u/AffectionateWar5927 </a> <a href="/r/Backend/comments/1sp1e2w/built_a_python_toolkit_for_easy_data_extraction/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1sp1hd8/built_a_python_toolkit_for_easy_data_extraction/">[comments]</a>

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

Built a python toolkit for easy data extraction

<div class="md">I learned Django framework and wanted to start a project on it. But I am stuck on fixating a project idea. I want to build an useful app. I see that there are many e-commerce based projects. For the first timer like me, I want mine to stand out from the rest and build an useful app that people want to try and use it. It gives a great satisfaction for anyone whose app is used or liked by many. With this context in mind, I request you people to suggest be some ideas. If you feel like someone should build an app to fix a problem that many users face, please tell me. If not me there are many wonderful people here, who may pick that problem and build an app. Thanks in advance. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/swaroop_34"> /u/swaroop_34 </a> <a href="https://www.reddit.com/r/django/comments/1snyce8/need_suggestions_on_project_idea/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1snyce8/need_suggestions_on_project_idea/">[comments]</a>

I learned Django framework and wanted to start a project on it. But I am stuck on fixating a project idea. I want to build an useful app. I see that there are many e-commerce based projects. For the first timer like me, I want mine to stand out from the rest and build an useful app that people want to try and use it. It gives a great satisfaction for anyone whose app is used or liked by many. With this context in mind, I request you people to suggest be some ideas. If you feel like someone should build an app to fix a problem that many users face, please tell me. If not me there are many wonderful people here, who may pick that problem and build an app. Thanks in advance. 
    submitted by    /u/swaroop_34  
 [link]   [comments]

Need suggestions on project idea

<div class="md">I am using DO App Platform with Space storage object. I have a csv model and when I try to upload a 250mb csv using django admin I get a 503 error, ~50mb and under works. I am wondering what is the correct way to upload large files like this? I have this process once a month loading this new set of data. <pre><code>class CSVFile(models.Model): file = models.FileField(upload_to=&#39;csv_files&#39;) name = models.CharField(max_length=100) </code></pre> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/AttractiveCorpse"> /u/AttractiveCorpse </a> <a href="https://www.reddit.com/r/django/comments/1srxjrc/large_csv_upload/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1srxjrc/large_csv_upload/">[comments]</a>

I am using DO App Platform with Space storage object. I have a csv model and when I try to upload a 250mb csv using django admin I get a 503 error, ~50mb and under works. I am wondering what is the correct way to upload large files like this? I have this process once a month loading this new set of data.
 class CSVFile(models.Model): file = models.FileField(upload_to='csv_files') name = models.CharField(max_length=100) 
    submitted by    /u/AttractiveCorpse  
 [link]   [comments]

Large csv upload

<div class="md">Two years ago, my friend and I launched a football prediction pool for the Euros with a twist. In a lot of pools, you can keep predicting boring scores like 1-0 and do surprisingly well. So we built our own system to make it more interesting: correct predictions would score points based on how unlikely they were. A predictable result would be worth less, while correctly calling a surprise scoreline would earn more. We used team ELO ratings and statistical models to estimate score probabilities, then based the scoring on those odds. At first it was just for our own friend group, but when we made it public for the Euros 2024, it actually took off more than we expected. We ended up with around 2,000 users, which felt huge for a small side project built mainly for fun. That momentum made us think we were onto something. So this year we went further: we relaunched under a new name, <a href="http://Goalguessers.com">Goalguessers.com</a>, and even built both Android and iPhone apps to make it feel like a proper product instead of a one-off tournament tool. But now the opposite is happening. Two years ago 2,000 people joined. This time, almost nobody is. Is the internet so flooded with AI products now that nobody notices handcrafted apps? </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/Pacemates"> /u/Pacemates </a> <a href="https://www.reddit.com/r/django/comments/1snt9al/from_2000_users_to_almost_none_are_handcrafted/">[link]</a> &#32; <a href="https://www.reddit.com/r/django/comments/1snt9al/from_2000_users_to_almost_none_are_handcrafted/">[comments]</a>

Two years ago, my friend and I launched a football prediction pool for the Euros with a twist. In a lot of pools, you can keep predicting boring scores like 1-0 and do surprisingly well. 
 So we built our own system to make it more interesting: correct predictions would score points based on how unlikely they were. A predictable result would be worth less, while correctly calling a surprise scoreline would earn more. We used team ELO ratings and statistical models to estimate score probabilities, then based the scoring on those odds.
 At first it was just for our own friend group, but when we made it public for the Euros 2024, it actually took off more than we expected. We ended up with around 2,000 users, which felt huge for a small side project built mainly for fun.
 That momentum made us think we were onto something. So this year we went further: we relaunched under a new name, Goalguessers.com, and even built both Android and iPhone apps to make it feel like a proper product instead of a one-off tournament tool.
 But now the opposite is happening. Two years ago 2,000 people joined. This time, almost nobody is. Is the internet so flooded with AI products now that nobody notices handcrafted apps?
    submitted by    /u/Pacemates  
 [link]   [comments]

From 2000 users to almost none: are handcrafted apps getting buried?

<div class="md">I have been learning Django for 2 weeks know and i am also familiar with React so i want some good projects i can work on to get comfortable with Django ? Any suggestions on where i should get some decent projects that can strengthen my django foundation? </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/djangolearning/comments/1sq48iy/django_projects/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1sq48iy/django_projects/">[comments]</a>

I have been learning Django for 2 weeks know and i am also familiar with React so i want some good projects i can work on to get comfortable with Django ?
 Any suggestions on where i should get some decent projects that can strengthen my django foundation?
    submitted by    /u/Leading_Property2066  
 [link]   [comments]

Django Projects!

<div class="md">I&#39;m doing a project, fully automated. Fetching data from an id card and saving it to the database is what I&#39;m working on now. but I tried so many tech stacks but no use. still some data is not fetching correctly. Don&#39;t know why. And also the client said API routing is not done in the project. What should I do. how to complete this project. </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/cum_onbaby"> /u/cum_onbaby </a> <a href="https://www.reddit.com/r/djangolearning/comments/1sn7pq2/python_django_api_doubt/">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1sn7pq2/python_django_api_doubt/">[comments]</a>

I'm doing a project, fully automated. Fetching data from an id card and saving it to the database is what I'm working on now. but I tried so many tech stacks but no use. still some data is not fetching correctly. Don't know why. And also the client said API routing is not done in the project. What should I do. how to complete this project. 
    submitted by    /u/cum_onbaby  
 [link]   [comments]

Python Django API Doubt

<div class="md">I just shipped ArchUnitPython, a library that lets you enforce architectural rules in Python projects through automated tests. The problem it solves: as codebases grow, architecture erodes. Someone imports the database layer from the presentation layer, circular dependencies creep in, naming conventions drift. Code review catches some of it, but not all, and definitely not consistently. This problem has always existed but is more important than ever in Claude Code, Codex times. LLMs break architectural rules all the time. So I built a library where you define your architecture rules as tests. Two quick examples: ```python <h1>No circular dependencies in services</h1> rule = project_files(&quot;src/&quot;).in_folder(&quot;/services/&quot;).should().have_no_cycles() assert_passes(rule) ``` ```python <h1>Presentation layer must not depend on database layer</h1> rule = project_files(&quot;src/&quot;) .in_folder(&quot;/presentation/&quot;) .should_not() .depend_on_files() .in_folder(&quot;/database/&quot;) assert_passes(rule) ``` This will run in pytest, unittest, or whatever you use, and therefore be automatically in your CI/CD. If a commit violates the architecture rules your team has decided, the CI will fail. Hint: this is exactly what the famous ArchUnit Java library does, just for Python - I took inspiration for the name is of course. Let me quickly address why this over linters or generic code analysis? Linters catch style issues. This catches structural violations — wrong dependency directions, layering breaches, naming convention drift. It&#39;s the difference between &quot;this line looks wrong&quot; and &quot;this module shouldn&#39;t talk to that module.&quot; Some key features: <ul> <li>Dependency direction enforcement &amp; circular dependency detection</li> <li>Naming convention checks (glob + regex)</li> <li>Code metrics: LCOM cohesion, abstractness, instability, distance from main sequence</li> <li>PlantUML diagram validation — ensure code matches your architecture diagrams</li> <li>Custom rules &amp; metrics</li> <li>Zero runtime dependencies, uses only Python&#39;s ast module</li> <li>Python 3.10+</li> </ul> Very curious what you think! <a href="https://github.com/LukasNiessen/ArchUnitPython">https://github.com/LukasNiessen/ArchUnitPython</a> </div> &#32; submitted by &#32; <a href="https://www.reddit.com/user/trolleid"> /u/trolleid </a> <a href="https://github.com/LukasNiessen/ArchUnitPython">[link]</a> &#32; <a href="https://www.reddit.com/r/djangolearning/comments/1sn50vd/i_built_archunit_for_python_enforce_architecture/">[comments]</a>

Hello, Python

Python Jobs 💼

I got tired of rebuilding OAuth for FastAPI projects, so I made a small CLI for it

FastAPI BackgroundTasks with retries, a live dashboard, persistence, and no broker.

I built ArchUnit for Python: enforce architecture rules as unit tests.

I built UIGen to auto-generate React frontends from FastAPI OpenAPI specs - here's what happened when I used it on a real internal app

HELP! I am having a tough time understanding the codebase

FastAPI documentation code not working?

Best Way to set up authentication out of the box

Looking for feedback on my new fastapi project

FastChannels and ChanX: The missing toolkit for WebSocket handling in FastAPI

Learning FastAPI — built a file upload endpoint, need advice on checksum and resumable uploads

Look for feedback on my fastapi project

codesips | Developer Cheat Sheets, Agentic AI & Solution Architecture Guides

DevLens: AI-powered codebase analysis & dead code detection

Built a 4-endpoint Text Utility API with FastAPI + HuggingFace — feedback welcome

First time deploying a Flask app to the web.

Flask Part 1 Up And Running

Flask Jinja Templates And Python Functions

WTForms vs Pydantic for forms

I have a method/function the problem is sometimes I want to redirect to 1 route and sometimes I want to redirect to another different route. How do I accomplish this ?

secure v2: HTTP security headers for Flask apps

Help me what to learn ?

django application with t3.micro can handle a lot of traffics..

DJForge: Production-Ready Django SaaS Boilerplate – Tailwind + daisyUI, Postgres, uv, Ruff

Most Celery tutorials cover the basics, but they rarely mention what can go wrong when publishing a message.

Django to Browser Push - Without WebSockets, Channels, or Redis

Is Django still a good choice?

What are people using for simple Django hosting these days?

PyCharm & Django annual fundraiser

Django Styleguide

ChanX: An extension library for Django Channels that makes building realtime applications a breeze

Your Models Know Their Own Schema. Let Them Show You.

Anyone with Django 6 + Ninja

DSF member of the month - Rob Hudson

Built a Django app for a client – no idea how much to charge. Need pricing advice.

New Technical Governance - request for community feedback

Why is my Django server slow

Built this task aggregator web app in Django + Vue.js. it fetches tasks from different platforms you use & also use AI to reschedule tasks or assign tags + other metadata to tasks.

I built ArchUnit for Python: enforce architecture rules as unit tests.

Solve coding challenges, get upvoted, earn points (and build with other devs)

DjangoMOO 1.0.0 — I built a MOO server on Django (with a RestrictedPython verb sandbox)

Quick Question: Hostinger Django Hosting

Is appliku still reliable?

Built a python toolkit for easy data extraction

Need suggestions on project idea

Large csv upload

From 2000 users to almost none: are handcrafted apps getting buried?

Django Projects!

Python Django API Doubt

I built ArchUnit for Python: enforce architecture rules as unit tests.