1102
Daily Python News Question, Tips and Tricks, Best Practices on Python Programming Language Find more reddit channels over at @r_channels
Looking for My First Backend Developer Role
Hi everyone. My name is Kaleb. I'm a Mechanical Engineering student who has spent the last couple of years teaching myself Python and Django. I've completed courses, read books, and built several projects, but I've reached a point where I feel like I need to work on real software with real people.
To be completely honest, I'm looking for even a small time hustle because I really need one. Financially, it would make a huge difference for me, but just as importantly, I don't want the hundreds of hours I've invested in learning to stop at personal projects. I want to contribute, learn from experienced developers, and become someone companies can rely on.
I'm not claiming to know everything. There are still plenty of things I need to learn, but I'm willing to put in the work. If I don't know something, I'll learn it. If a task takes extra effort, I'll stay until it's done. What I can promise is consistency, curiosity, and a strong desire to improve.
If you're part of a startup, agency, open-source team, or know someone looking for a junior Django/Python developer or intern, I'd be incredibly grateful if you could point me in the right direction. Even if it's a small opportunity, I'd love the chance to prove myself.
If you've read this far, thank you. If you can't offer an opportunity, even an upvote or sharing this post with someone who might be hiring would mean a lot to me.
Thank you.
https://redd.it/1uupd7l
@pythondaily
Zer0Fit: I took Google's new TabFM & TimesFM ML foundation models and made them available as an MCP server for zero-shot ML tasks (forecasts / classifications / regressions). 100% local. [P]
https://redd.it/1uue8cc
@pythondaily
I needed one feature for my SaaS. Six hours later... I had launched another SaaS.
/r/SaaS/comments/1uu8ne6/i_needed_one_feature_for_my_saas_six_hours_later/
https://redd.it/1uu96l9
@pythondaily
JupyterLite 0.8 is released! 🎉
https://blog.jupyter.org/jupyterlite-0-8-is-released-0c89c4200f79
https://redd.it/1utyc2s
@pythondaily
Building a tool for offline coding practice on flights/trips — would you actually use this?
Hey everyone,
I'm a developer working on a side project/startup idea and wanted to get honest feedback before I sink more time into it.
The idea: a website where you pick a programming language and a specific track (e.g., Go basics, or backend development with Go), and it generates a downloadable offline package — documentation, tutorials, and exercises — packed into a zip file. You download it before you lose internet access (long flight, train, remote area, wherever), and once offline you just open it in your browser like a normal site. No connection needed.
I know there are already tools like DevDocs, Dash, and Zeal that let you save documentation offline. What I'm trying to do differently is focus on structured learning tracks with exercises, not just a raw doc viewer — more like a self-contained mini-course you can work through with zero connectivity.
I'm trying to figure out monetization without doing a subscription (that already feels like the wrong model for something people might use a handful of times a year). Current thinking is one-time purchase per track, or eventually partnering with airlines.
Genuine questions for you all:
1. Would you pay a small one-time fee for something like this?
2. Would you use it even if it were free — or does existing offline documentation (Dash, DevDocs, etc.) already solve this well enough for you?
3. What would make this actually useful vs. just another doc viewer?
Trying not to build something nobody wants, so brutally honest feedback is welcome. Thanks!
https://redd.it/1utrchl
@pythondaily
team
**Bonus**: this setup also makes AI coding assistants noticeably more effective. There's exactly one place to change (the serializer), everything downstream regenerates, and a hallucinated endpoint or param fails to compile instead of failing at runtime.
Full write-up with the complete configs and gotchas: [https://huynguyengl99.github.io/posts/schema-first-api-development-drf-react/](https://huynguyengl99.github.io/posts/schema-first-api-development-drf-react/)
If people are interested, I can put together a small open source demo project showing the whole pipeline end to end when I have some free time, so let me know.
Happy to answer any questions.
https://redd.it/1uto6kt
@pythondaily
file-observer: deterministic, mostly-stdlib file observation with a reproducible JSON manifest
I build data-adjacent tooling as a hobby, and I kept needing the same boring thing: point something at a directory and get back a precise, reproducible description of every file — type, size, structure, embedded metadata — as JSON I could diff and check into a pipeline. So I wrote it, and it's grown into something I use enough that it's worth sharing.
What My Project Does
file-observer walks a directory and emits a deterministic JSON manifest: identity, filesystem metadata, checksum, MIME analysis, structural signatures, and format-specific fields. The load-bearing property is the boring one — same bytes in, byte-identical manifest out, every run. There's a test that scans with 1 worker and with N workers and fails CI if the two manifests differ, so parallelism can never introduce drift.
A few things that keep it lean and honest:
\- Mostly stdlib. The format specialists — PDF, OOXML (docx/xlsx/pptx), images with EXIF, MP4/MOV, MP3, email, and more — are written on `struct` / `zipfile` / `olefile` rather than heavy dependencies. Core install is small.
\- It observes; it doesn't interpret. No OCR, no classification, no model. It reports what's measurably in a file and stops there — and it never executes file content, so it stays a safe thing to point at untrusted input.
\- Several front doors. A CLI (`fo`), a one-call Python API (`from file_observer import scan`), `--stdout` for pipelines, a committed JSON Schema for any-language consumers, and an MCP server for agent tooling.
\- Bring-your-own word lists (one newer use case). Hand it a category-tagged list and it counts matches per file — the list is supplied at runtime, never shipped, never echoed back. Handy as a deterministic pre-screen in front of anything that reads untrusted files, an AI agent included.
Target Audience
Data-pipeline and cataloguing work, CI checks, provenance/inventory over a corpus — anywhere you want a stable, diffable description of a pile of files. It's on PyPI, has \~1,400 tests, and runs on Linux/macOS/Windows. Honest framing: I'm an enthusiast, not a professional, and fo is deliberately just an observer — it hands you signal and you own what to do with it. It's production-usable for what it claims (deterministic observation), not a magic file-understanding engine.
Comparison
`python-magic` / `file` tell you a file's type and stop. Apache Tika extracts rich content across formats — powerful, but it exists to pull content out, pulls in a large parser surface, and needs a JVM. file-observer sits in a different spot: dependency-light and mostly-stdlib, focused on describing a file rather than extracting its content, with output that's byte-for-byte reproducible so it fits in a pipeline or a CI gate. Where Tika answers "what's in this file," fo answers "what is this file, exactly and repeatably."
\---
pip install file-observer
Repo + design write-ups: https://github.com/russalo/file-observer
It's an enthusiast project and I'm fairly isolated from people who do parsing or security for a living, so critical eyes on it — including the unflattering kind — are exactly why it's here.
https://redd.it/1utlito
@pythondaily
How does ACL conferences acceptance work [D]
Even after getting ARR reviews and a meta review, how is the acceptance decided at the \ACL venues, because I have seen meta review 3.5 getting to findings and 3 getting to main or even getting rejected. Then what is the purpose of the overall score and recommendation? What do the conferences see when deciding?
Do they only care about the metareview and their comments, or the whole set of reviews as well as along with the track in which the paper was submitted.
Anyone knowing the process please kindly tell.
Thank you [D\]
https://redd.it/1ut5krb
@pythondaily
Predicting human preference for generated image pairs using HPSv3 P
Hey! I'm looking for ways to predict human preference for a project I'm building. (imagebench.ai)
I've tryed HPSv3, https://github.com/MizzenAI/HPSv3 and made post about it here:
https://imagebench.ai/blog/does-the-score-match-your-eye
It looks ok, but have many limitation as you can see in my post.
My question. Have you tried other human preference model and found one that would be better then HPSv3?
https://redd.it/1utdj1f
@pythondaily
SUGGESTIONS for CUET UG 2027 COMPUTER SCIENCE
Hey,
I will be opting COMPUTER SCIENCE as a domain subject in CUET UG 2027
so can anyone recommend me from where I can study or any youtube channels!
https://redd.it/1utant4
@pythondaily
Feeling imposter syndrome after "Django for APIs"—is relying on Concrete Views (ListCreateAPIView) bad practice?
https://redd.it/1uqw3hb
@pythondaily
Why doesn't the ML research community limit the number of submissions per author? D
I am currently working across multiple research communities, and I've noticed that the ML community is struggling with a massive volume of submissions, which is affecting review quality (as we are seeing in the recent ARR cycles).
I am wondering what the reasoning is for not limiting the number of submissions per author?
This practice has been successfully used in other research areas for years, such as Security (e.g., CCS) or Computer Architecture (e.g., DAC), to help keep workloads manageable. Is there a particular cultural reason why the ML community chooses a different approach?
https://redd.it/1usq43t
@pythondaily
Pure python can be faster than cython/rust?
Parsing multipart/form-data (HTML5 forms) is surprisingly complex and moves a lot of bytes around for large file uploads. Implementing a parser in Cython or Rust should speed things up, no? Turns out: it depends. A pure python parser can be surprisingly fast, as this benchmark shows:
https://defnull.de/2026/python-multipart-benchmark/
The benchmark compares the most commonly used multipart parsers and tests them in different scenarios, covering both blocking and non-blocking (async) APIs if available. The parser your web application is using today is probably not the fastest one.
Are there more examples were a pure python implementation beats cython/rust/C?
https://redd.it/1usid6y
@pythondaily
Is there ever a point where you don't feel like an idiot?
Like I have fun coding in python and making dumb little projects, but every time i do, I'm always thinking about how there's probably a better way to do it. And know that I'm trying to explore doing things with a raspberry pi, I just feel really dumb. Like everything I do doesn't matter as much because there is probably a better way to do what I did.
https://redd.it/1usfgmg
@pythondaily
Hyperparameter tuning approach question R
I am doing some work with cell type classification, where I have 4.3 million cells and 512 features (condensed embeddings from the encoder of a transformer).
The broader goal is to implement a contextual bandit for augmenting the training set of the dataset, as it is currently imbalanced, and rare cell type classification is poor when I tried a baseline logistic regression classifier.
Dataset:
Feature matrix shape: (4290471, 512)
Labels shape: (4290471,)
Class distribution:
T cell 1966941
DC 858451
NK cell 561904
Monocyte 411170
B cell 375882
Platelet 54576
Progenitor cell 24689
ILC 24254
Erythrocyte 12604
I didn't do any hyperparameter tuning for the LR classifier, but I want to try other ML models (LightGBM, XGBoost, SVM)
However, I face a bottleneck with hyperparameter tuning. I want to do 80/10/10 train/validate/test split, but the training set is so large and takes a long time even on H100.
What are some solutions to this? I tried optuna but still very long for each hyperparameter trial. I then tried optuna but instead of using the full 80% for training each time, only 15% of the 80% is used (subsampling from the training set). I'm not sure if this is robust or not. I also couldn't really find anything in the literature.
Anyone been in a similar situation?
https://redd.it/1usa46w
@pythondaily
You don't need to deploy to test a webhook integration. Tunnel your local server instead.
Noticed this pattern comes up a lot: someone's building something that needs a third-party service to call their server (a webhook, an OAuth callback, anything), and the first instinct is to deploy to a real host just to get a public URL to register.
That means every single test cycle looks like: change code, deploy, wait for the deploy, trigger the webhook, check logs on the remote server, repeat. Minutes per iteration, easily.
There's a much faster loop. A tunnel exposes your actual local dev server to the internet, no deploy needed at all. I've been building a webhook-heavy project entirely this way, verification handshake, duplicate detection, outbound API calls, database schema, all of it tested against a real third-party service hitting my laptop directly. Haven't deployed anywhere yet and don't need to until much later.
How it actually works, briefly: the tunnel client on your machine opens an outbound connection to the tunnel provider's cloud servers. Outbound connections aren't blocked by home routers or firewalls the way inbound ones are. When the external service hits your public tunnel URL, the request gets pushed back down through that already-open connection to your local machine, forwarded to whatever port your dev server is actually running on. Your dev server has no idea any of this happened, it just sees a normal incoming request.
The iteration loop this enables: change code, dev server auto-reloads, trigger the real webhook again, see the result in your local logs, all in seconds. No deploy step in the middle at all.
I've been using ngrok specifically, free tier is enough for development, reserved domains mean you don't have to re-register the URL with the third party every time you restart it. Similar tools exist too if you want alternatives.
Only real limitation: this is explicitly a development tool. Your laptop has to stay on and the tunnel process has to keep running, so it's not something to rely on for anything production facing, just the build-and-test loop before you actually deploy.
https://ngrok.com/
https://redd.it/1uuh1qb
@pythondaily
My project has 600+ manage.py commands and a 28s boot. Watching agents run --help on them one by one made me update my completion tool
A couple of months ago I released `django-completion` to get smart tab-completion for [manage.py](http://manage.py) (it maps your own commands, their flags, app labels, migration names, etc.).
Then I noticed I barely type [manage.py](http://manage.py) commands myself anymore. Claude Code does it for me. So the question for v0.3 became: can the same tool help the agent?
Before building anything, I wanted to see how Claude actually uses `manage.py`. I scanned 6 weeks of my Claude Code history across two machines, about 4,200 commands that agents actually ran. Two things came out of that:
1. When an agent needs to learn a project's commands, it runs --help command by command, and each call boots Django. On my work project (600+ management commands, \~28s per boot) that's minutes. The other way agents do it is grepping the code, which misses built-in and third-party commands.
2. My original plan was to intercept [manage.py](http://manage.py) calls and serve --help from a cache. The data killed it: that pattern is too rare to be worth the machinery. What agents need isn't a faster --help, it's a source of truth they check first.
Conveniently, my tool already maintained that source of truth: a local cache file with every command, flag, and migration name, refreshed silently after each [`manage.py`](http://manage.py) run.
So for v0.3, I made it agent-readable:
* The agent reads one JSON file, no Django boot at all.
* Or runs `python` [`manage.py`](http://manage.py) `autocomplete context` for a compact summary.
* A short snippet in CLAUDE.md / AGENTS.md points the agent to it.
GitHub: [https://github.com/soldatov-ss/django-completion](https://github.com/soldatov-ss/django-completion)
https://redd.it/1uuavs2
@pythondaily
Sunday Daily Thread: What's everyone working on this week?
# Weekly Thread: What's Everyone Working On This Week? 🛠️
Hello r/Python! It's time to share what you've been working on! Whether it's a work-in-progress, a completed masterpiece, or just a rough idea, let us know what you're up to!
# How it Works:
1. Show & Tell: Share your current projects, completed works, or future ideas.
2. Discuss: Get feedback, find collaborators, or just chat about your project.
3. Inspire: Your project might inspire someone else, just as you might get inspired here.
# Guidelines:
Feel free to include as many details as you'd like. Code snippets, screenshots, and links are all welcome.
Whether it's your job, your hobby, or your passion project, all Python-related work is welcome here.
# Example Shares:
1. Machine Learning Model: Working on a ML model to predict stock prices. Just cracked a 90% accuracy rate!
2. Web Scraping: Built a script to scrape and analyze news articles. It's helped me understand media bias better.
3. Automation: Automated my home lighting with Python and Raspberry Pi. My life has never been easier!
Let's build and grow together! Share your journey and learn from others. Happy coding! 🌟
https://redd.it/1utzp3j
@pythondaily
What Every Python Developer Should Know About the CPython ABI
> It's true that you can happily write Python for years without needing to understand any of the content of this post, so you may object to the title advertising this material as what every Python developer should know. However, the moment you ship a package, debug why a wheel won't install, or need to understand why an import or Python function call segfaults — these details start to matter. Even writing and maintaining a single-file script puts you closer to distributing code than you might think. An alternate title for this post could be "What I Wish Someone Taught Me About the CPython ABI".
https://labs.quansight.org/blog/python-abi-abi3t
https://redd.it/1uts313
@pythondaily
Public Library Find [D]
https://redd.it/1utplzc
@pythondaily
Advanced API development with DRF + React: schema-first, end-to-end types, auto-generated client and forms
Hi everyone, I want to share the setup my team has been using for a few years to eliminate a whole class of bugs: the backend renames a field, the frontend keeps sending the old one, and nothing complains until production. Since adopting this, we simply haven't faced outdated params or wrong response shapes anymore.
The core idea: the OpenAPI schema is the protocol between BE and FE. The backend generates it, the frontend generates FROM it, and type checkers on both sides refuse to compile anything that violates it.
https://preview.redd.it/7n8xlm1akmch1.png?width=1600&format=png&auto=webp&s=d81a3fcb5f110c51ec66b07754b98456d9e7e173
**Backend side**
Everything flows from the serializers, so the habit is: always declare serializer\_class and queryset, override get\_serializer\_class() per action:
class ProjectViewSet(ModelViewSet[Project]):
queryset = Project.objects.all()
serializer_class = ProjectSerializer
permission_classes = [IsAuthenticated, IsProjectMember] # reused, not repeated
def get_serializer_class(self) -> type[BaseSerializer[Project]]:
if self.action == "list":
return ProjectListSerializer # lighter payload for lists
return super().get_serializer_class()
drf-spectacular serves the schema live at /api/schema/, always in sync with the code by construction (in stricter environments you can commit an exported schema file instead, either works). Settings that matter:
* COMPONENT\_SPLIT\_REQUEST: True is mandatory, otherwise read-only fields (id, timestamps) leak into request schemas and break FE mutations
* Name enum fields by concept (task\_status, not status) or they collide in the component registry
* Polymorphic types need a postprocessing hook to force discriminators as required, or the generated validation marks them optional
* CAMELIZE\_NAMES: True if your JS consumers prefer camelCase
Typing: mypy strict (with the django-stubs plugin, since Django's metaprogramming needs it) plus pyright for fast in-editor feedback. Type serializers as ModelSerializer\[Project\].
**Frontend side**
With the backend dev server running, one command regenerates everything from /api/schema/ (openapi-zod-client with --group-strategy tag-file, wrapped in zodios):
pnpm gen:all
# → src/schemas/backend/ zod schemas, one file per OpenAPI tag
# → src/types/backend/ TypeScript interfaces
# → src/services/backend/ typed zodios API clients
const project = await projectsApi.projectsRetrieve({ params: { id } });
// rename a field on the backend, regenerate, and this line
// turns red before you even run anything
The zod schemas pay twice: the same generated schemas power runtime API validation AND form validation, up to fully auto-generated forms. When a serializer gains a field, the form grows it on the next regenerate - no manually synced form definitions.
**Why DRF over Django Ninja for this**: ViewSets model an API kind, not a function. You get reusable permission classes instead of decorating every endpoint, and the tags/grouping flow directly into the generated client structure.
**Why the type hints and the contract matter so much**
* Type errors surface before tests even run. Together with tests, you get real confidence in the codebase, and IDE suggestions become genuinely good, which speeds up coding a lot
* Honest note: you will probably hate strict typing for the first few weeks (I did, on both mypy and TypeScript). Push through it. Once it clicks, contract changes become impossible to miss and you start thanking the type checker for catching production bugs early
* For teams, the contract, the tests, and the types are must-haves rather than nice-to-haves. They kill the silent, unspoken change: every contract change shows up in the generated files, so git and reviewers always see it, and lint/type checks fail if someone forgot to regenerate. Nobody has to remember to tell the frontend
Withdraw from ACL ARR and resubmit to a workshop? D
Hey guys,
I received mediocre scores for my EMNLP paper during the May ACL ARR cycle: 2.5/3, 3/4, 2.5/4. The paper is in the Interpretability track. The reviewers had no larger issue with the methodology or the paper in general, but it seemed like they didn't fully get the so what of my paper. I've tried to clarify everything in my rebuttal, but I don't assume that the reviewers will engage in the discussion. With the current scores, I won't make it to the conference and likely not even into findings. Hence, I was thinking of withdrawing the paper, if scores don't improve, improve the presentation of my paper, and submit it to the BlackboxNLP workshop by the end of next week.
As I'm a first year PhD student, I'm not so familiar with ACL ARR, and how best to approach this. Hence, I wanted to ask you guys. Should I keep the paper in the cycle and hope for the best (or switch to the conference at a later stage) or should I withdraw it directly, adjust it slightly, and head directly to the workshop?
https://redd.it/1uth7j8
@pythondaily
Loveable VS Django website
I posted here few days ago, that I started learning Django and one of the guy commented that "Why learn Django when AI can build websites". So I'm asking from experienced people that AI websites are good enough to beat Django websites??
https://redd.it/1uteyoj
@pythondaily
Python study guides?
Hi! I just joined and I’m currently learning about coding at my school and I’m taking an online course that uses Python Cisco learning academy (If anyone is familiar) I’m coming up on taking my finals and I haven’t been able to find thorough study guides. Anyone in the community know of any? like flash cards, websites that have practice exams, etc. Tried Quizlet and refuse to pay to study lol
https://redd.it/1utczac
@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/1ut4i7l
@pythondaily
Please help me understand figure on subspace similarity in LoRA paper. [D]
https://redd.it/1uso667
@pythondaily
Mapping world model taxonomy P
Hey ML community! I’ve been exploring world models and wrote a short article aimed at making the concept easier to understand.
I also propose a framework for classifying different approaches and highlight a few trends that emerge from that classification.
I’d appreciate feedback on the framework, especially where it may be incomplete, unclear, or technically inaccurate.
Article: https://x.com/srini\_sunil\_/status/2075577335076598194?s=20
https://redd.it/1usp482
@pythondaily
django-query-doctor: 5.5k downloads later, I finally feel okay sharing it here
Every Django project I've worked on has had the same story.
Something feels a little slow. You open Debug Toolbar, and there it is: 340 queries on a page that should run 3. You add a select_related, ship it, move on. Six weeks later someone adds a SerializerMethodField that reaches into a related object, and you're right back where you started. Nobody notices until a customer does.
The tooling for finding it once is great. The tooling for never regressing again is basically nonexistent.
So I built django-query-doctor. It watches your queries, tells you in plain language what's wrong and where, and can fail your CI build if a PR turns 3 queries into 30.
I've been working on it quietly for a while now, mostly using it on my own projects and watching how it behaves. It's sitting at about 5.5k downloads on PyPI, which is honestly more than I expected, and enough that I've stopped treating it as a weekend thing. Feels like the right moment to actually say hello here.
It's free, MIT licensed, works on Django 4.2 through 6.0.
pip install django-query-doctor
Repo: https://github.com/hassanzaibhay/django-query-doctor
Docs: https://hassanzaibhay.github.io/django-query-doctor
I'd really like to hear where it breaks. Large codebases with unusual ORM patterns are exactly the thing I can't simulate on my own, and false positives are the fastest way to make a tool like this useless. If you try it and it annoys you, tell me why. That's the more useful feedback anyway.
One question for the room: how are you catching query regressions today? assertNumQueries, APM in staging, or mostly vibes and customer complaints? Curious whether a CI gate feels helpful or just noisy.
Please drop a star or open an Issue if you think it is something interesting. Thank You
https://redd.it/1usg4kj
@pythondaily
Djxi v0.1.7 released!
Hey r/django! I made a small django package that helps to improve LoB when working with Django and HTMX. The scattering of views, urls and small template snippets can get messy. Djxi simply unifies all three into a single endpoint battery, allowing a more feature-centric development.
Please check it out!
Github: [https://github.com/rollinger/djxi](https://github.com/rollinger/djxi)
ReadtheDocs: https://djxi.readthedocs.io/
PyPi: [https://pypi.org/project/djxi/](https://pypi.org/project/djxi/)
Django Packages: https://djangopackages.org/packages/p/djxi/
https://redd.it/1usev99
@pythondaily
Are you using some online Python notebook editor?
Hello everyone, i am a programmer and i am looking forward to do some cool projects, are you already using one of these online editors?
https://redd.it/1us8qha
@pythondaily
