Python Daily

Django/Python Internship or Junior Backend Job in 2026 — What Should I Focus On? Hi everyone, I’m a 2023 CSE graduate preparing for my first role in Python/Django backend development. My current stack includes Python, Django, DRF, MySQL, Redis, Celery, Docker, Git, and pytest. I’ve built some small projects, but I don’t have professional experience yet. I’m mainly targeting backend internships and junior/fresher Django positions, and I’d really appreciate advice from developers, recruiters, or hiring managers. For internships: How do companies usually hire Django/Python interns in 2026? What do recruiters/hiring managers actually look for in an intern’s CV and GitHub? What skills are considered enough to get an internship? Do internships usually require DSA, or are Django/DRF, SQL, and projects more important? What kind of projects would make an internship candidate stand out? For junior/fresher roles: What skills are actually expected from a Junior Django Backend Developer? How strong should I be in Django/DRF, SQL, Docker, Redis/Celery, testing, Linux, and deployment? How important are DSA and system design? What does the typical hiring process look like—from CV screening → technical interview → coding/task → final interview? What are the most common reasons junior candidates get rejected? Without internship or professional experience, what is the best way to prove that I’m job-ready? Finally, if you were in my position today, what would you focus on for the next 6 months to realistically land an internship or junior backend role? I’m looking for practical insights from people who have recently hired or been hired, rather than generic advice. Thanks! https://redd.it/1vorhht @pythondaily

How much does adding an honest limitations section hurt the paper? D Hi, How much does adding an honest limitations section hurt the paper (apart from making it better)? Does it bias the reviewers? Will they want you to fix the things in the limitations section? If the reviewers let AI read the paper, will the limitations section bias AI? Would it be better if the limitations section was hidden from the reviewers? And if the reviewers would have to author a limitations section? https://redd.it/1voksgz @pythondaily

Saturday Daily Thread: Resource Request and Sharing! Daily Thread # Weekly Thread: Resource Request and Sharing 📚 Stumbled upon a useful Python resource? Or are you looking for a guide on a specific topic? Welcome to the Resource Request and Sharing thread! ## How it Works: 1. Request: Can't find a resource on a particular topic? Ask here! 2. Share: Found something useful? Share it with the community. 3. Review: Give or get opinions on Python resources you've used. ## Guidelines: Please include the type of resource (e.g., book, video, article) and the topic. Always be respectful when reviewing someone else's shared resource. ## Example Shares: 1. Book: "Fluent Python" \- Great for understanding Pythonic idioms. 2. Video: Python Data Structures \- Excellent overview of Python's built-in data structures. 3. Article: Understanding Python Decorators \- A deep dive into decorators. ## Example Requests: 1. Looking for: Video tutorials on web scraping with Python. 2. Need: Book recommendations for Python machine learning. Share the knowledge, enrich the community. Happy learning! 🌟 https://redd.it/1vonnet @pythondaily

How I structure a Django project for production from day one One of the things I have changed over the years is how much structure I put into a Django project before building the first real feature. Django’s default project structure is a good starting point, and for prototypes or smaller applications I am quite happy to keep things simple. The problems tend to appear later. A single settings.py grows environment-specific conditionals. The default user model becomes difficult to replace. Business logic starts appearing in views. Shared code gradually accumulates in utils.py. Deployment configuration lives partly in the repository and partly in someone’s memory. None of these are particularly difficult problems at the beginning of a project. They become much more expensive once the application has production data, integrations and multiple developers working on it. I now make a small number of structural decisions early: \- Split settings by environment \- Create a custom user model before the first migration \- Organise Django apps around business responsibilities \- Keep the core app deliberately small \- Give business logic a clear home outside the HTTP layer \- Treat APIs as another interface to the same application logic \- Keep infrastructure such as storage and email configurable \- Make testing and deployment part of the project from the beginning The important distinction for me is that this does not mean building everything on day one. I do not need Redis, Celery, Sentry or cloud storage running locally before I have written a feature. I just want the project to have an obvious place for those concerns when they arrive. That is the balance I try to strike between keeping Django simple and avoiding completely predictable restructuring later. I have written up the full project structure I use, including settings, apps, services, APIs, background tasks, infrastructure, testing and deployment: https://www.digitaledgeconsulting.co.uk/blog/how-i-structure-a-django-project-for-production As with my previous post about service layers and thin views, this is not intended as the correct way to structure every Django project. It is simply the structure I have arrived at after building and maintaining larger Django applications in production. I would be interested to hear which decisions other people make at the start of a production Django project, and which ones you deliberately leave until later. https://redd.it/1vohc2x @pythondaily

Looking for honest feedback on my Django/DRF e-commerce project ​ Hi everyone, I'm a final-year CS student preparing for my first Python/Django backend role. I recently built this e-commerce project and would really appreciate an honest review from experienced Django/backend developers. **GitHub Repository:** https://github.com/abhishekc8205/django-ecommerce-platform \### Tech stack * Python * Django * Django REST Framework * SQLite * JWT authentication * Stripe * Pillow \### What the project has * User registration/login/logout * Buyer and seller functionality * Seller product management * Product search, category filtering, sorting and pagination * Product variants (size/color) * Product image galleries * Customer reviews * Shopping cart * Checkout flow * Stripe checkout with local testing fallback * Seller sales dashboard * REST APIs for products and categories * JWT access/refresh token APIs * Seller-only permissions for creating/updating/deleting products I'm targeting **Python/Django backend fresher roles**, so I'd especially like feedback on: 1. Is this strong enough to be my **main resume project**? 2. How would you rate the Django/DRF implementation? 3. Does the project look like more than basic CRUD? 4. Are there any obvious bad practices or security issues I should fix? 5. Is the authentication/authorization approach reasonable? 6. What parts of the code would you improve? 7. What features would actually make this project stronger for backend interviews? 8. If you were interviewing me based on this project, what questions would you ask? 9. Would you consider this a good project for a **Django backend fresher**? I'm looking for **honest criticism rather than compliments**. I want to improve the project before using it in my job applications. Thanks in advance for taking the time to review it! https://redd.it/1vog5dn @pythondaily

attune-forms is now on PyPI — and as of this week, it's a Claude Code plugin. Last week I wrote about the idea: an agent's question should be a typed, validated artifact, not a sentence. This week the machinery shipped as a standalone open-source library. attune-forms gives AI coding agents a second channel beside free-form chat: declarative, validated forms. Independent decisions batch into one round-trip instead of twenty questions. Malformed questions are refused at build time; malformed answers are refused at collection time. Nothing is silently accepted in either direction. Beyond plain fields, three constructs carry conversational meaning: • Decision — the agent proposes: recommended option first, a "why" rationale, a one-line tradeoff under every alternative. • Pushback — structured disagreement: your approach and the agent's alternative side by side, and overruling the agent is a first-class outcome, not a failure. • Progress — a status report whose blocked items become a picker: reading the status and unblocking the work are the same gesture. One schema, three surfaces: an interactive HTML widget where the host renders rich content, batched plain questions in the terminal, native MCP elicitation where the host supports it. The form degrades — it never breaks. Two ways in. As a Claude Code plugin (skill + MCP server, no Python setup): claude plugin marketplace add Smart-AI-Memory/attune-forms claude plugin install attune-forms@attune-forms As a Python library: pip install attune-forms Python 3.10+, one runtime dependency, 380+ tests, CI on Linux/macOS/Windows, Apache 2.0. The part I keep coming back to: every scoping and design decision in building this library ran through the grammar itself — v0.1.0 to v0.4.0 in three days, dogfooded end to end. The full argument: https://www.linkedin.com/pulse/communication-grammar-ai-agents-patrick-roebuck-sutse Code: https://github.com/Smart-AI-Memory/attune-forms https://redd.it/1vo8kp2 @pythondaily

With the release of Wallet Usernames for Cloudflare I had made a python project that helped me understand networking in python a little bit. Let me know what I should implement that would help me learn a little more about networking with python. (I have a small background in rev engineering and c++) https://github.com/xssiq/WalletCF_UsernameChecker https://redd.it/1vodi95 @pythondaily

I compiled Doom's renderer into a 21B-parameter transformer -- no training anywhere P This is the project my last two posts were building towards (this is the last of this silliness). I ported the Doom rendering algorithm to run inside a transformer. Instead of training a model, I used a compiler I wrote which converts computation graphs into transformer weights, and then ported Doom's algorithm into a compatible graph. The generated checkpoints can be loaded in Hugging Face without trust_remote_code -- it's just a standard transformers checkpoint. You feed the model a prompt representing the scene data, and generate until the model stops. The result is a token sequence which includes simple pixel drawing commands (to move the cursor, draw a pixel, etc). When you mechanically apply those drawing commands you get the rendered frame. The article includes the entire host program necessary to load the checkpoint, generate the render, and parse the output into the famous E1M1 frame. This host code is 43 lines of python. The python to define the computation graph is much longer, but that gets compiled into the transformer itself. One frame is a 3,614-token prompt plus 53,747 generated tokens -- just over 40 minutes on a B200. The original Doom could achieve 35 FPS on a 486. This achieves 35 FPD (frames per day) on a B200. Write-up: https://ood.dev/posts/doom/ Weights: https://huggingface.co/physicsrob/torchwright-doom-e1m1 Github for the source code which gets compiled: https://github.com/physicsrob/torchwright\_doom/ https://redd.it/1voazhm @pythondaily

Need Tips and Recommendations on migrating a project from ASP.NET MVC to DRF. On the company i work for, we mostly use DRF, but there is this one project, written on .net mvc, that no one dares to touch anymore, the plan is to migrate the project, it is sort of small. Somehow I got stuck as a tech leader even when i'm nothing of the sort, and I have to lead my team on migrating the app. Which is something i have never done before tbh. So that's why i come to you all, to give me some tips on how to approach this move, what would you recommend to start with?? I don' t want to make this more complicated than it should. Like should i start with models or matching controllers to views ... im so open to hear your opinions and tips. https://redd.it/1vo95d1 @pythondaily

For the people who got reviews back from neurips, cvpr, eccv, etc and also tested their paper through an agentic reviewer like the stanford one, how different were the reviews? D Hello, I was curious about the differences you can get from the human reviewers and the llms. Any insight is welcome, thank you! https://redd.it/1vo5vdm @pythondaily

Other Python forums - Stack Overflow Not sure if I am allowed to discuss other forums on here but I'm sure someone will tell me if not. It is just me of has anybody else encountered problems with the 'moderators' on Stack Overflow Python forums recently? To say I've found them to be a self-righteous bunch of destructive power-crazy control-freaks would be a bit of an understatement. Anyone else had problems on there? https://redd.it/1vo3rrb @pythondaily

TMLR Relevance and Prestige D I recently had a paper accepted to TMLR and was wondering how prestigious it is, in comparison to A* conferences (ie. NeurIPS, ICLR, ICML), but also vs journals like JMLR. https://redd.it/1vnqk4k @pythondaily

apiver: a DRF library for defining API versions as deltas, not duplicates Across a few past projects working with big teams, I kept seeing the same pattern: API versioning handled differently every time, no consistent convention, URLs and view logic getting messier with each "just add a v2" hack, version-checking if branches scattered wherever someone needed them that week. And every time an actual breaking change needed to ship, it was a struggle — nobody had a clean answer for "how do we change this without breaking the clients still on the old version." So I built apiver — a DRF library where you define API versions as deltas, not full copies. You say "V2 is V1, except this endpoint changed" and everything else just resolves straight through to your existing code, untouched. The bigger shift isn't really the code, it's the mindset: instead of versioning being an ad-hoc thing someone bolts on whenever a breaking change is due, it becomes a structured, first-class part of how you ship — and adopting it is frictionless, since it wraps whatever you already have instead of asking you to rewrite it. What you get: Frictionless adoption — `apiver init` wraps your project exactly as it is, no file moves, no big-bang migration. A whole new API version for the cost of one override() call. Deltas are just plain Python subclasses — no DSL to learn. Pick your own version scheme — sequential (v1, v2), semver (v1.2.3), or date-based (2026-08-11). \- Auto-generated, correct-per-version OpenAPI schemas. \- Real deprecation lifecycle — Deprecation/Sunset headers + enforced sunset dates. \- `apiver squash` — once old versions are dead weight, collapse the whole delta chain back into one clean base instead of dragging every ancestor forward forever. \- Full CLI — apiver versions, apiver diff, to actually see what each version serves. apiver mount to create/mount a new version. And some more. It's pre-1.0 and honestly just scratching my own itch, but if it's useful to anyone else dealing with this same mess, I'd genuinely love feedback — reporting issues, "this doesn't fit my use case because X", "Docs are confusing", anything. 🙏 Repo: https://github.com/edraobdu/apiver Docs: https://apiver.readthedocs.io/en/latest/ https://redd.it/1vnqwap @pythondaily

Friday Daily Thread: r/Python Meta and Free-Talk Fridays # Weekly Thread: Meta Discussions and Free Talk Friday 🎙️ Welcome to Free Talk Friday on /r/Python! This is the place to discuss the r/Python community (meta discussions), Python news, projects, or anything else Python-related! ## How it Works: 1. Open Mic: Share your thoughts, questions, or anything you'd like related to Python or the community. 2. Community Pulse: Discuss what you feel is working well or what could be improved in the /r/python community. 3. News & Updates: Keep up-to-date with the latest in Python and share any news you find interesting. ## Guidelines: All topics should be related to Python or the /r/python community. Be respectful and follow Reddit's Code of Conduct. ## Example Topics: 1. New Python Release: What do you think about the new features in Python 3.11? 2. Community Events: Any Python meetups or webinars coming up? 3. Learning Resources: Found a great Python tutorial? Share it here! 4. Job Market: How has Python impacted your career? 5. Hot Takes: Got a controversial Python opinion? Let's hear it! 6. Community Ideas: Something you'd like to see us do? tell us. Let's keep the conversation going. Happy discussing! 🌟 https://redd.it/1vnrksf @pythondaily

request with that token in the `Authorization` header 4. Call the third-party API 5. Log the call (`APILog`: user, endpoint, method, status, response size) 6. Format and return the response ​ { "status_code": 200, "result": "...", "quota": { "used": 4, "remaining": 96, "limit": 100, "usage_pct": 4.0 } } # Why centralize this instead of handling OAuth in every service? * **A single place to store secrets** — your `client_id` / `client_secret` don't end up scattered across ten different microservices' codebases * **Automatic, shared refresh** — the token is cached and refreshed once, even if multiple services call the same API * **Unified quota and logging** — you know exactly who's calling what, and how much it costs in credits * **Transparent provider changes** — if the third-party API changes its token URL or scopes, there's only one place to update # Going further Everything else (API keys, quotas, rate limiting, response formats) follows the same simple pattern: register declaratively once, then call it through `/execute/`. The project is open source (Django 5.x + DRF, PostgreSQL): 👉 [**github.com/asstgr/asstgropensource**](https://github.com/asstgr/asstgropensource) If you find the project useful, a ⭐ goes a long way, and you can follow updates on [u/asstgrio](https://x.com/asstgrio). https://redd.it/1vnmjak @pythondaily

How to Handle OAuth 2.0 Authentication to Third-Party APIs with Asstgr (self-hosted) If you've ever had to integrate an OAuth 2.0-protected third-party API into multiple projects, you know the drill: handle the authorization flow, store the tokens, track their expiration, build automatic refresh logic... and start over on every new project. **Asstgr** is a self-hosted API gateway (Django + DRF) that centralizes all of this. The idea: you register a third-party API once in Asstgr, describe its endpoints, and then call it through a unified REST interface — Asstgr takes care of authentication, quota, and logging on your behalf. In this article, we'll focus on one specific use case: **how to connect an OAuth 2.0-protected API to Asstgr**, and call it without ever handling a token by hand. # The concept Your app ──► Asstgr (/api/v1/...execute/) ──► OAuth2-protected third-party API │ ├─ Auth (API Key or OAuth2) ├─ Quota ├─ Logs └─ Response formatting Your application only needs to know one thing: your Asstgr API key (`sk-...`). Asstgr internally handles all exchanges with the third-party API's OAuth server (fetching, caching, and refreshing tokens). # Supported flows Asstgr supports the three most common OAuth 2.0 grants, with automatic token refresh: * `client_credentials` — for server-to-server integrations (the most common case) * `authorization_code` — for APIs requiring explicit user authorization * `password` — for legacy ROPC-based APIs # Step 1 — Register the API We start like with any other API in Asstgr: POST /api/v1/apis/ { "name": "My Protected API", "url": "https://api.example.com/v1", "auth_required": true, "quota_cost": 2 } # Step 2 — Configure OAuth 2.0 This is where it gets interesting. We attach an OAuth configuration to the API through the dedicated endpoint: POST /api/v1/apis/{api_id}/oauth/ { "grant_type": "client_credentials", "token_url": "https://api.example.com/oauth/token", "client_id": "your_client_id", "client_secret": "your_client_secret", "scope": "read write" } The `client_secret` is stored encrypted server-side (`client_secret_encrypted` in the database). Once this configuration is saved, Asstgr knows how to obtain a token for this API. # Checking token status You can check at any time whether a valid token is currently cached: GET /api/v1/apis/{api_id}/oauth/token/ # Forcing a refresh If needed (debugging, secret rotation on the provider's side, etc.), you can manually force a token refresh: POST /api/v1/apis/{api_id}/oauth/token/ Under normal circumstances this isn't necessary: Asstgr's internal service (`OAuthService`) checks token expiration (`token_expires_at`) before every call and refreshes it automatically if needed, completely transparently. # Step 3 — Describe the endpoint and its parameters Just like with a regular API, we add the endpoint and its parameters: POST /api/v1/apis/{api_id}/endpoints/ { "path": "/protected-resource", "description": "OAuth2-protected resource" } POST /api/v1/apis/{api_id}/endpoints/{endpoint_id}/parameters/ { "name": "resource_id", "param_type": "query", "data_type": "STRING", "required": true } POST /api/v1/apis/{api_id}/endpoints/{endpoint_id}/methods/ { "method": "GET" } # Step 4 — Execute the call And here's the main payoff: from your application, a single call, using your Asstgr key — no OAuth token to manage: POST /api/v1/apis/{api_id}/endpoints/{endpoint_id}/execute/ Authorization: Api-Key sk-xxxxxxxxxxxxxxxxxxxxxxxx { "method": "GET", "params": { "resource_id": "42" }, "display_format": "standard" } Asstgr will, in order: 1. Verify your API key and remaining quota 2. Fetch (or refresh) the OAuth2 token associated with that third-party API 3. Build the actual HTTP

City2Graph: A Python library for Heterogeneous Graph Neural Networks and spatial analysis in urban systems [R] https://redd.it/1vn8oya @pythondaily

Dsa or Django? I am fairly new into programming. So I am familiar with the basics of python. Have made some terminal based projects as well. Started dsa concepts yesterday but it is boring me out. I do plan on learning both but is it a good idea to get some real experience with django and web projects first? (I have knowledge of html, css and little bit js) Also, I am in my first year of graduation so time is not a concern! https://redd.it/1vn23vn @pythondaily

Have you ever needed a composable, reusable WebSocket framework - like DRF, but for Channels? Hi all, I maintain a utility package that extends Django Channels (WebSocket/ASGI). I'm thinking about building a small framework in the same spirit as DRF and its ecosystem, but aimed at Channels/WebSockets - things like audio streaming, notifications, bidirectional chat, chat rooms, and so on. Before I start, I wanted to ask the community: have you ever needed something like this? For example, you had to implement a WebSocket feature, struggled with it, and went looking for a tutorial or library that already solved the problem and came up empty. If these are real pain points, I think there's room for a reusable library. Looking forward to hearing your thoughts. https://redd.it/1vmykuo @pythondaily

Thursday Daily Thread: Python Careers, Courses, and Furthering Education! # Weekly Thread: Professional Use, Jobs, and Education 🏢 Welcome to this week's discussion on Python in the professional world! This is your spot to talk about job hunting, career growth, and educational resources in Python. Please note, this thread is not for recruitment. --- ## How it Works: 1. Career Talk: Discuss using Python in your job, or the job market for Python roles. 2. Education Q&A: Ask or answer questions about Python courses, certifications, and educational resources. 3. Workplace Chat: Share your experiences, challenges, or success stories about using Python professionally. --- ## Guidelines: - This thread is not for recruitment. For job postings, please see r/PythonJobs or the recruitment thread in the sidebar. - Keep discussions relevant to Python in the professional and educational context. --- ## Example Topics: 1. Career Paths: What kinds of roles are out there for Python developers? 2. Certifications: Are Python certifications worth it? 3. Course Recommendations: Any good advanced Python courses to recommend? 4. Workplace Tools: What Python libraries are indispensable in your professional work? 5. Interview Tips: What types of Python questions are commonly asked in interviews? --- Let's help each other grow in our careers and education. Happy discussing! 🌟 https://redd.it/1vmuw0z @pythondaily