31 ms·

Django Styleguide

177 points by r4victor 4y ago

warinukraine 4y ago
I hate making webpages, but Django makes it as bearable as it can be. I hate python, but love Django. I think I have some sort of emotional attachment to Django.
olau 4y ago
I think there are too many concepts in this, but rather than being negative, here are some tips: Always keep your models slim. Don't stuff template related stuff in there. You need to look at those models often, so compact is a win. course_has_finished(course) is not much longer than course.has_finished(), and will allow you to expand the functionality as time goes on. Do precomputation if you need the information in a template - that keeps your templates simpler and allows you to easily expand the complexity of the precomputation. Don't use class-based views, at least not outside very specific niches like the Django admin. Class-based views will transform a simple, composeable call stack into a ball of inheritance mud. Inheritance is not a good code reuse tool. Don't make separate apps in the same project, unless the project actually consists of several different, completely independent projects. You can make subdirectories without making apps, and thus avoid dependency hell. Also be wary of the formerly South, now built-in migrations stuff. It's built around a fragile model (perfect history representation), so has lots of foot guns. And be wary of 3rd party libraries with their own models. You can spend a lot of time trying to built bridges to those models compared to just doing what makes sense for your particular project. I think 3rd party libraries are perhaps best implemented without concrete models - duck-typing in Python let us do this. This includes Django itself, by the way. User profiles didn't become good until Django allowed you to define the user model yourself.
- drcongo 4y ago
  Agree with all of this, although I do like class based views.
  - nicolaslem 4y ago
    Me too, I think it's important to acknowledge that no approach is perfect. Pick your poison.
- VWWHFSfQ 4y ago
  Agree with migrations. I've spent a lot of time doing migration surgery to get things back into a consistent state. But mostly I've found that if you just let Django manage the database how it wants to then things will be fine. But get very familiar with merge migrations and fake migrations if things start to go awry. I disagree with the perspective on CBVs though. I've been programming Django since 0.96 and CBVs have made nearly everything easier and better for me.
- rlawson 4y ago
  Good points. Agree with slim models and I personally like a service layer. FBVs are great, CBVs are ok, GCBVs are of the devil
- roland35 4y ago
  Is there a better alternative to South (built-in now) for migrations? I always had issues but figured it was the de facto for a reason.
- Daishiman 4y ago
  > Don't use class-based views, at least not outside very specific niches like the Django admin. Class-based views will transform a simple, composeable call stack into a ball of inheritance mud. Inheritance is not a good code reuse tool. People always say this but well-structured CBVs keep a generic interface that you'll be really glad that exists when you have 80 views spread across 10 apps. Composing function-based views is a PITA and when you're building an API with a bunch of auth/serialization/cache extras being bolted on it's way easier to keep disciplined and ordered. It is _trivial_ to mess up the order of callers for these things inside function-based views.
- rajasimon 4y ago
  > Don't make separate apps in the same project, unless the project actually consists of several different, completely independent projects. You can make subdirectories without making apps, and thus avoid dependency hell. I wrote an article on this. My goto strategy is to create a project/core/views.py,models.py,apps.py,tests.py
  - cjohnson318 4y ago
    > I wrote an article on this. Link or it didn't happen :)
    - rajasimon 4y ago
      lol forgot to include
  - cjohnson318 4y ago
    Are you talking about this: https://rajasimon.io/blog/django-project-structure/ https://rajasimon.io/blog/django-project-structure/
    - rajasimon 4y ago
      yup that's that. Thanks for finding it for me :)
- randlet 4y ago
  "Also be wary of the formerly South, now built-in migrations stuff. It's built around a fragile model (perfect history representation), so has lots of foot guns." My experience has been opposite so I'd be interested in hearing your experiences if you are willing. I have been using the built in migrations since day 1 on a medium sized Django project with 350+ migrations and migration issues for our project have been exceedingly rare. edit: We have a small team of developers, so merge migrations are very rare for us, which might be a contributing factor.
  - rowanseymour 4y ago
    Same here. If I was starting a non-Python project tomorrow I'd consider using Django to manage the database schema - especially now that we can describe custom indexes and constraints in migrations. Our project has gone thru over 1000 migrations so far tho we squash them down to 50 or so about once a year.
    - jbellew 4y ago
      Thats interesting, if I was using TypeScript to access the data, how would I keep the schemas in sync between TS and python?
      - rowanseymour 4y ago
        I've never used TypeScript to talk to a database but there might be tooling to generate classes from tables. Even if there isn't, manually keeping some TypeScript classes in sync might still be worth the effort, for being able to manage schema migrations easily elsewhere.
      - dnadler 4y ago
        We do this manually along with a pydantic as a middleman between Django and TS. Works pretty well and is not a major inconvenience to keep things aligned.
      - anileated 4y ago
        Can introspect and export Django models to JSON schema or similar, then in TS read it and use compiler low-level API to generate types. There may be libraries for either stage…
- switch007 4y ago
  Apps should be buried deep in the documentation in some “super advanced” section and not advocated much at all
- rowanseymour 4y ago
  > You can make subdirectories without making apps, and thus avoid dependency hell. It's hard to get 100% right and thus our projects always have a few lazy foreign key relationships and inline imports to avoid cyclical imports... but I think our code is easier to manage because we try to model the dependency relationships by having things in separate apps. > Also be wary of the formerly South, now built-in migrations stuff Our experience from South to 4.x has been that the models/migrations system has matured significantly and is probably now the main selling point for Django for us.
  - cjohnson318 4y ago
    I'm currently in circular import hell. My business logic has Jobs and Loads, and they both need to update each other under certain circumstances. Should these two things/monstrosities be lumped into the same app?
    - hbrn 4y ago
      The short answer is yes. The long answer is if two entities are updating each other you might benefit from shifting all update responsibilities to one of them. Or even to a third entity that knows about both and keeps those two isolated from each other.
      - cjohnson318 4y ago
        Woof. Thank you so much. I like the idea of a third party, like a mediator. Would that mediator be another app? Or should it be some module sitting in the project directory? (I'm not even sure Django would import something like that.)
        hbrn 4y ago
        > Would that mediator be another app? Yes! It is an app that might not even have any model classes. But it will contain business logic. And it will probably speak domain language, which is great. If you're lucky, those two other apps will become pluggable. You will probably never replace them, but separation of concerns is always nice. The downside of course is that you will have 3 apps instead of 1. That's the balance you have to maintain.
- rglullis 4y ago
  > Always keep your models slim. As simple as possible, but no simpler. Django models are meant to deal not just with the data, but also with business logic. If `course.has_finished` is a property of the course, why would you want to have a separate function outside of the class? > Do precomputation if you need the information in a template If the precomputation is only needed in a template, you can (should, IMO) use template tags. > Don't make separate apps in the same project (...) avoid dependency hell. My current pattern here has been to create one "core" project where I represent all the internal models of the domain of the application, and "adapter" apps if I want to interface/integrate with anything from the external world. This makes it easier to extend or replace third-party tools. > (Migrations) It's built around a fragile model. I wouldn't call it fragile, quite the opposite. There are some annoying limitations for sure (I didn't find a reliable way to change the primary key of a model, except for creating a whole new model and migrating the data to it), but I think they are due to a matter of strong safety that the migration can only be done if it consistent.
  - well1912 4y ago
    At my current company, we've had many teams over the years fail to make business logic in model methods work, and I think many other people have had similar results. The issues usually boil down to some combination of "business logic is too coupled to the data model" and "this method lives at an intersection of these two models and creates weird dependency problems". I now feel that Django puts you down a path for failure by naming the DB layer "models" and not giving users a decent place to put cross-model domain logic. My current preference is a functional core-imperative shell-style architecture where as much code lives in the functional core as possible. It's not very elegant with Django but it works fine. Cosmic Python (really accessible and fairly quick read if you have the time: https://www.cosmicpython.com/book/preface.html https://www.cosmicpython.com/book/preface.html) has examples that are similar.
    - rglullis 4y ago
      > The issues usually boil down to some combination of "business logic is too coupled to the data model" and "this method lives at an intersection of these two models and creates weird dependency problems". Refactor is not a dirty word. The problems you are describing seem to be more of the nature of having too many things concentrated at specific model classes, and that this model should be decomposed, broken down. This is not a Django-specific issue.
- yiiii 4y ago
  > Always keep your models slim. At least never put your business logic in your views, forms or even templates.
  - collyw 4y ago
    I am in more or less in agreement, except for forms. Surely some validation could be considered business logic.
- dec0dedab0de 4y ago
  Always keep your models slim. Don't stuff template ...course_has_finished(course) is not much longer than course.has_finished() I disagree with this. When trouble shooting or expanding code it is super convenient to import a model and have all of your methods on auto complete. Especially when you need the same functionality in a view, a cron job, a celery task, and an DRF end point. If you want to keep it clean you can put all your methods in a mixin class and import it from another file. Also be wary of the formerly South, now built-in migrations stuff. Things are much better than they were in South. But yes be careful, rule of thumb is always move forward. Don't use class-based views Please. For the love of God, always use class based views for almost everything. Almost everything you need is a variant of one of the built in class based views, don't make me read your copy/pasted reimplementation of it.
  - cjohnson318 4y ago
    > Please. For the love of God, always use class based views for almost everything. This. 100%. Leverage as much pre-built stuff you can, especially with something as important as your HTTP layer. Whenever I run out of CRUD verbs for a model and I need to add a custom endpoint, I'll implement it in a separate APIView sublcass. Convention over configuration; write boring code.
  - asalahli 4y ago
    In my view (hehe), Django's class based views is a good idea implemented poorly. In theory you should be able to use any of the built-in class based generic views with minimal customizations to suit your needs, except when you want to do such customizations you're left dealing with a huge inheritance tree of mixins. It's all magic unless you know or wanna read the documentation on what each mixin brings to the view, that is _if_ you know what mixins are involved exactly, of course.
    - collyw 4y ago
      Are you aware of https://ccbv.co.uk/ https://ccbv.co.uk/? After I discovered that, class based views became easy.
- collyw 4y ago
  I disagree with almost everything you have said. Fat models think controllers is the suggested strategy. It works well in my opinion / experience, though I guess it could get out of hand on very large projects. There is something that feels very unnatural and unintuitive about your course_has_finished(course) versus course.has_finished() example. This was one of the principles behind OOP, keeping your data and functions / methods together, though I know OOP isn't trendy these days. It's far more natural to have it as a method of course than some random function, stored who knows where. I worked on a system with this type of design, it was pretty bad. One thing I would like to see for larger projects is the ability to easily split models into separate files - a bit more like Java does with one class per file. Maybe you can do this already. Class based views mean that a lot of code is written and tested for you. I'll agree that your view does need to be somewhat "standard" in what it's doing (anything you would see in the admin, list, create, edit, detail, login, etc), so if you have something more complex multiple forms in one view, then thy don't give a great deal of advantage. In that situation I would still likely choose a basic View class over functional views, but more for consistency. I am probably in agreement on separate apps. Migrations are one of the best features of Django. I have just spent 4 years working on a a system without them and it was a shambles as you would expect. Everyone is scared to make database changes, so you get a ton of shitty application code to compensate for shitty database modelling. Tech debt in other words. I can't think of any 3rd party apps where I have used the models directly, or if I did it was frictionless enough for me not to remember. So no real opinion on that one. 3rd party apps can be pretty hit and miss, especially if they get abandoned as you upgrade Django, so I would say use with caution, particularly for more obscure ones (just been revisiting django-celery-beat, that's been around for years so I doubt it's going away).
- __pache__ 4y ago
  how is this possibly the highest upvoted thing here on django. it's like the opposite of good opinions.. they're bad opinions! _(99% kidding, but i disagree with most of this lol)_
deleted 4y ago
[deleted]
j4mie 4y ago
I've been heavily inspired by this styleguide over the years, but I still think it's a bit too complex. A few random thoughts: - I think "services" is too much of a loaded term. I prefer "actions", and I always use the function-based style. - I hate the naming of "APIs" in this document. They use the term "API" when they mean "endpoint" or "view". - "Reuse serializers as little as possible" is the single best piece of advice when using DRF. The inline InputSerializer thing is brilliant. - Having each each endpoint only handle a single HTTP verb is brilliant. - URLs and views should be separate from all other business logic (models, actions etc). - For read endpoints and associated business logic, I'd encourage https://www.django-readers.org/ (disclaimer: I'm the author).
- miketery 4y ago
  > "Reuse serializers as little as possible" is the single best piece of advice when using DRF. The inline InputSerializer thing is brilliant. Can you expand on this? What is the InputSerializer as opposed to custom rest serializers?
  - hbrn 4y ago
    I think the idea is that instead of thinking "here's the object I'm serializing" you should think "here's the view (endpoint) I'm serializing for". Contrary to what people usually think, the shape of the serialized object is typically defined by the API endpoint, not by the object itself. Different endpoints can (and will) serve different shapes of the same object. Even if two endpoints serve the same shape today, they can deviate tomorrow. When this happens, most people are trying to resolve it through DRF inheritance, which is wrong.
- collyw 4y ago
  After 20 years in this industry I firmly believe that the code reuse thing is way oversold in universities. It seems to be the reason for so much crappy over engineered monstrosities. YAGNI and KISS are far better things to aim for. Avoid duplicate code, but don't start out aiming for reusable code, when most of the time your requirements won't be especially clear.
greenSunglass 4y ago
I've been working on a project with flask + sqlalchemy. I have those sql queries returning a bit of rows (up to 20k) and that are quite slow. SQLalchemy does not seem to support caching the results and I've started to use flask-caching[1] with redis using the @cache.memoize() decorator. Just wondering if I am taking the right path or if there is better alternative. [1]https://flask-caching.readthedocs.io https://flask-caching.readthedocs.io
- Frotag 4y ago
  I've been using nginx for caching when the response isn't user-specific. Pretty painless to set up and doesn't bloat the codebase. (But it's mostly for small personal projects, so grain of salt and all.) https://www.nginx.com/blog/nginx-caching-guide/ https://www.nginx.com/blog/nginx-caching-guide/
- zhte415 4y ago
  Indexed? If complex, what does Sqlalchemy output as the SQL? Could you optimise the query? If quite complex, optimise the tables by redesigning them? Was the move to allow Redis to cache persistently across requests? Does it do this? Are you timing each function to look for slowness?
- biorach 4y ago
  > flask-caching[1] with redis using the @cache.memoize() decorator. > Just wondering if I am taking the right path or if there is better alternative. Yes, this can be a fine solution to slow queries and is used very often in many kinds of web applications. However... 20k rows is not a very big number for a modern dB. If the db query is really the slow part then you should investigate why - ensure the relevant sql queries are written properly, and that the relevant tables are indexed properly for the queries that you are running on them.
hbrn 4y ago
Ah, the typical "where to put business logic in Django". M in ActiveRecord MVC web frameworks is deeply misunderstood. M is not "data model" (it would be called DVC if that was the case). M is your domain model. It's the model of your business, model of the real world. It's the core of your application. Another thing that I never understood, why are functions called services? Is it a subconscious desire to go back to enterprisey kingdom of nouns? (apparently it is [1]) A service is either something that lives on a network (e.g. database, payment gateway, microservice). Or a class that has a state. Your functions are neither of those, they are just functions. You business logic should live in the "models" namespace. Whether you put it on Model classes, or onto custom Managers, or just dump them into the module is not important, as long as you keep it consistent and keep your apps fairly small and isolated from each other. Django already gives you enough tools to support big "enterprise" applications. It is far from perfect, but you'll get much further if you embrace the framework instead of fighting it. If you really are attached to this "services" mindset then Django API Domains [2] is your best option. [1] https://www.b-list.org/weblog/2020/mar/16/no-service/ https://www.b-list.org/weblog/2020/mar/16/no-service/ [2] https://github.com/phalt/django-api-domains https://github.com/phalt/django-api-domains
- roflyear 4y ago
  I never understood why this was so hard or why people complicate this so much. You have a segment of your application that "does stuff" - some mix of classes and functions. This stuff has its own API. Then you have your web views call that code through that API (which is probably just calling functions...). No, instead, it is that "does stuff" hast to be its own library, or god forbid, its own service that lives somewhere else, with its own communication layer, its own auth... Why are we making this so hard on ourselves?
  - hbrn 4y ago
    Typically it goes like this: 1. You found one case where complexity is essential. 2. That one case is not consistent with the rest of your app, and you were taught that inconsistency is bad. 3. Since you can't remove complexity from that case, for the sake of consistency you add complexity to all other cases. Class-based views is a typical example. You found a place where CBVs are useful. Now some parts of your app use functions, some use classes, that's inconsistent. Edit your style guide to enforce CBV everywhere. Now a simple healthcheck endpoint that returns "OK" has to be a class. As some folks used to say, you can write Java in any language. The right approach, of course, is to say "I'd rather have inconsistency than complexity". The challenge is that perception of complexity is subjective, but inconsistency is objective. So the right approach eventually loses, and every organization turns into a bureaucratic hell.
cproctor 4y ago
I've found it helpful in several projects to implement the "services layer" described here as a state machine, modeling state transitions for a central object (e.g. an article can be drafted, submitted, reviewed, published). The state machine enforces permissible transitions and handles side effects which touch other models.
spapas82 4y ago
In a similar fashion, for anybody interested I've written some of my guidelines on implementing Django apps: https://www.spapas.net/2022/09/28/django-guidelines/ https://www.spapas.net/2022/09/28/django-guidelines/
zenith035 4y ago
Don't create apps just for the sake of project structure even when models from multiple apps are closely related. Moving models from one app to another is doable but it is a pain. It's even worse if you are relying on GFKs.
chairmanwow1 4y ago
HN comments are really disparaging, but after reading through I really liked the content and am going to pull out their service / serializer model to use in my project. Nice opinionated way to avoid structuring a program in a bad way.
theptip 4y ago
On testing, I think "one file & class per thing-to-test" is subtly bad advice. It's not harmful in the hands of someone that knows what they are doing, but it tends to point engineers towards a tightly-coupled test suite, which ends up making refactoring more painful and error prone down the road. If you have one testclass per entity, then if you make any changes to the structure of your services/models/entities, you must restructure your tests too. This means you can't do the "dream refactor" where you don't touch your tests, and restructure your code without changing any behavior. If you rewrite your tests whenever your structure changes, how can you be sure you've not broken your tests? Instead, I advocate for testing behaviors. In a tightly-integrated framework like Django, most of your tests are going to be integration tests (i.e. you have a database involved). You should bias those tests towards an integration-y approach that uses the public interfaces (Service Layer, if you have one) and asserts behavior. Ideally the tests should not change if the business logic has not changed. (In practice you'll often need to add some mapping/helper/setup code to make this true.) If you have any fat-model type behavior that is explicitly scoped to a single model, then you can test that in isolation. Many Django projects call these "unit tests" even though they still involve reading and writing your model from the DB. I call them "focused integration tests". All that matters is that you have agreement on terminology inside your project. If you have extremely complex domain logic, it can be worthwhile to construct "true Unit Tests" that use dummy objects to test logic without hitting your DB. I've not found it worthwhile to mock the DB in most Django projects though. To provide an example of where my "test behaviors not classes" advice differs from the OP's paradigm, let's say you split out a sub-object to provide a pluggable Strategy for a part of your Model's behavior -- you don't necessarily need to have detailed tests for that Strategy class if it's fully covered by the model's tests. Only the edge cases that are awkward to test at the higher level need to be tested at the granular level of the Strategy. Indeed, the first refactor that just creates a Strategy holding your existing behavior need not change any of your existing tests at all! Indeed, if you do need to change existing tests, that suggests your tests were improperly-coupled to the code under test, since a mere structural change like this should not affect the behavior of your application. Even after adding more Strategy logic, most of your old ModelTests are still good; they still test the high-level behavior, and now also test the integration between your model and the new Strategy class. Basically, test at the most-granular level that gives a clear, decoupled test for your behavior; resist testing every entity in isolation, because some entities have rich coreographies with other entites that make them hard to isolate. Sometimes you have to contort and tightly-couple in order to test things at the very-lowest-level possible. Inspiration/further reading: https://blog.cleancoder.com/uncle-bob/2017/10/03/TestContravariance.html https://blog.cleancoder.com/uncle-bob/2017/10/03/TestContrav.... (Grit your teeth through the "Socratic dialog" style. The principle being described is extremely valuable.)
OgAstorga 4y ago
Somewhat off-topic but django is fundraising over here https://www.djangoproject.com/fundraising/ https://www.djangoproject.com/fundraising/
KyeRussell 4y ago
I have a long-running thread on the Django forums with a bunch of opinions about this topic: https://forum.djangoproject.com/t/structuring-large-complex-django-projects-and-using-a-services-layer-in-django-projects/1487 https://forum.djangoproject.com/t/structuring-large-complex-...
Rastonbury 4y ago
I found this useful being someone who was self taught django and hacked together a project with no idea of architecture. To this day I don't even know what a selector is referring to lol never used it I'm learning node now for another mini project, is there anything similar? I know how it achieve certain tasks but to structure in a proper way I know nothing, all tutorials I've done never really go that deep
radoslav_ 4y ago
Hello everyone, Radoslav here (one of the authors of the mentioned Django Styleguide). First of all - I want to thank everyone to the comments The fact that someone took the time to read the styleguide & then write a comment / propose a different POV - is humbling. I've read everything once & I'll do so at least couple more times. There are interesting ideas & comments that we can apply! And finally, I want to add some more context: 1. That particular styleguide has served us, and it's still serving us well. It's basically a list of ideas that we found useful, thanks to the various Django projects that we've been exposed to at HackSoft. 2. One core philosophy of the style guide is the ability to cherry-pick whatever makes sense to you. Even at our company, it's very rare to have 2 Django projects following the exact same structure. The styleguide is rather a framework / direction for things that's been proven to work, from our experience. 3. And of course, the styleguide can use some more love from us. We are sitting on a lot of unshared knowledge that needs to be structured and applied back to the Django Styleguide & the corresponding Django Styleguide example project. 4. We try to keep it pragmatic, so you can actually build something. For example, DDD sounds great, but lacks pragmatism and slows you down by a lot (at least, for us). 5. And finally - this is not the "only right way" to do Django. As there is no "right way" to build software. Luckily, there are always options. We'll update the list of other suggested approaches, so people can have a choice / navigate the space better. As an example of one of the big topics that we want to touch upon is nesting apps. Alongside the "services / selectors" layer (btw - you can call this whatever suits you best ), the ability to nest apps within apps is really powerful, when it comes to the structure and longevity of a Django project. Having 50+ flat apps is not the best experience. Our current focus is around building the company (HackSoft). The Django Styleguide will be soon to follow. We are slowly gaining more speed & we'll eventually get there All discussion around "How to do Django" are in fact really interesting. If we happen to meet at some future EuroPython / DjangoCon Europe - I'm always open to discuss in person. Otherwise, if you have specific comments / suggestions - you can submit it either as an issue / discussion, or just send an email to radorado@hacksoft.io Cheers!
- radoslav_ 4y ago
  By the way, we are discussing more of this in our latest podcast episode (HackCast) here - https://www.youtube.com/watch?v=9VfRaPECbpY https://www.youtube.com/watch?v=9VfRaPECbpY Cheers!
drcongo 4y ago
Can't believe they're putting `class Meta` at the bottom of models.
- YPCrumble 4y ago
  What’s wrong with that?
  - drcongo 4y ago
    It's a pet peeve more than anything - I just hate it when I have to scroll around to find if a class is abstract or not, our team puts it at the top so that's never an issue. Having it anywhere else means it can be any arbitrary number of lines below the class definition making it harder to find.
    - deleted 4y ago
      [deleted]
    - KyeRussell 4y ago
      I’ve never worked on a Django codebase that puts Meta at the top of a model definition. Not saying that it’s the wrong hint to do, but this just feels like feigned surprise because you surely also know that it’s far from common.
      - drcongo 4y ago
        It very much was feigned surprise, though I do know a few Django devs who prefer top. I've never really understood the logic for hiding it in the middle or at the bottom even though both are much more common.
  - yiiii 4y ago
    The official coding style guide lines already state that it should come immediately after the fields. https://docs.djangoproject.com/en/dev/internals/contributing/writing-code/coding-style/#model-style https://docs.djangoproject.com/en/dev/internals/contributing...
andybak 4y ago
> We use Celery for the following general cases: > > Communicating with 3rd party services (sending emails, notifications, etc.) > Offloading heavier computational tasks outside the HTTP cycle. > Periodic tasks (using Celery beat) Sigh. No mention of the trade-offs. There's simpler ways to do all these things. Celery is a big complex beast and it always pains me to see it as the default suggestion for simple tasks.
- andrewingram 4y ago
  I've been using the beta of Temporal's Python SDK with Django, and aside from some minor teething issues, it's very nice.
- 69Represente 4y ago
  I have a bug with celery i can't solve. when I send an async job that get data from various APIs and write all in a DB, in the case of lot there is lot of data, the celery task finish properly to but my flask app becomes unresponsive. I have to restart flask to get back to a normal state. Anyone would know where I should check?
  - roflyear 4y ago
    sounds like a resource issue, maybe you are opening application contexts and not handling them properly?
- aequitas 4y ago
  A lot of people use Django with uWSGI, which also comes with queues, cron, workers, cache and lots more. I've been stuck with Celery on previous projects for reasons. But I've been dying to try out uWSGI's built in features for this. Hearing great things about it. https://uwsgi-docs.readthedocs.io/en/latest/Spooler.html https://uwsgi-docs.readthedocs.io/en/latest/Spooler.html https://uwsgi-docs.readthedocs.io/en/latest/Cron.html https://uwsgi-docs.readthedocs.io/en/latest/Cron.html https://uwsgi-docs.readthedocs.io/en/latest/Mules.html https://uwsgi-docs.readthedocs.io/en/latest/Mules.html https://uwsgi-docs.readthedocs.io/en/latest/Caching.html https://uwsgi-docs.readthedocs.io/en/latest/Caching.html

177 points by r4victor 4y ago

I hate making webpages, but Django makes it as bearable as it can be. I hate python, but love Django. I think I have some sort of emotional attachment to Django.

olau 4y ago

I think there are too many concepts in this, but rather than being negative, here are some tips: Always keep your models slim. Don't stuff template related stuff in there. You need to look at those models often, so compact is a win. course_has_finished(course) is not much longer than course.has_finished(), and will allow you to expand the functionality as time goes on. Do precomputation if you need the information in a template - that keeps your templates simpler and allows you to easily expand the complexity of the precomputation. Don't use class-based views, at least not outside very specific niches like the Django admin. Class-based views will transform a simple, composeable call stack into a ball of inheritance mud. Inheritance is not a good code reuse tool. Don't make separate apps in the same project, unless the project actually consists of several different, completely independent projects. You can make subdirectories without making apps, and thus avoid dependency hell. Also be wary of the formerly South, now built-in migrations stuff. It's built around a fragile model (perfect history representation), so has lots of foot guns. And be wary of 3rd party libraries with their own models. You can spend a lot of time trying to built bridges to those models compared to just doing what makes sense for your particular project. I think 3rd party libraries are perhaps best implemented without concrete models - duck-typing in Python let us do this. This includes Django itself, by the way. User profiles didn't become good until Django allowed you to define the user model yourself.

drcongo 4y ago
Agree with all of this, although I do like class based views.
- nicolaslem 4y ago
  Me too, I think it's important to acknowledge that no approach is perfect. Pick your poison.
VWWHFSfQ 4y ago
Agree with migrations. I've spent a lot of time doing migration surgery to get things back into a consistent state. But mostly I've found that if you just let Django manage the database how it wants to then things will be fine. But get very familiar with merge migrations and fake migrations if things start to go awry. I disagree with the perspective on CBVs though. I've been programming Django since 0.96 and CBVs have made nearly everything easier and better for me.
rlawson 4y ago
Good points. Agree with slim models and I personally like a service layer. FBVs are great, CBVs are ok, GCBVs are of the devil
roland35 4y ago
Is there a better alternative to South (built-in now) for migrations? I always had issues but figured it was the de facto for a reason.
Daishiman 4y ago
> Don't use class-based views, at least not outside very specific niches like the Django admin. Class-based views will transform a simple, composeable call stack into a ball of inheritance mud. Inheritance is not a good code reuse tool. People always say this but well-structured CBVs keep a generic interface that you'll be really glad that exists when you have 80 views spread across 10 apps. Composing function-based views is a PITA and when you're building an API with a bunch of auth/serialization/cache extras being bolted on it's way easier to keep disciplined and ordered. It is _trivial_ to mess up the order of callers for these things inside function-based views.
rajasimon 4y ago
> Don't make separate apps in the same project, unless the project actually consists of several different, completely independent projects. You can make subdirectories without making apps, and thus avoid dependency hell. I wrote an article on this. My goto strategy is to create a project/core/views.py,models.py,apps.py,tests.py
- cjohnson318 4y ago
  > I wrote an article on this. Link or it didn't happen :)
  - rajasimon 4y ago
    lol forgot to include
- cjohnson318 4y ago
  Are you talking about this: https://rajasimon.io/blog/django-project-structure/ https://rajasimon.io/blog/django-project-structure/
  - rajasimon 4y ago
    yup that's that. Thanks for finding it for me :)
randlet 4y ago
"Also be wary of the formerly South, now built-in migrations stuff. It's built around a fragile model (perfect history representation), so has lots of foot guns." My experience has been opposite so I'd be interested in hearing your experiences if you are willing. I have been using the built in migrations since day 1 on a medium sized Django project with 350+ migrations and migration issues for our project have been exceedingly rare. edit: We have a small team of developers, so merge migrations are very rare for us, which might be a contributing factor.
- rowanseymour 4y ago
  Same here. If I was starting a non-Python project tomorrow I'd consider using Django to manage the database schema - especially now that we can describe custom indexes and constraints in migrations. Our project has gone thru over 1000 migrations so far tho we squash them down to 50 or so about once a year.
  - jbellew 4y ago
    Thats interesting, if I was using TypeScript to access the data, how would I keep the schemas in sync between TS and python?
    - rowanseymour 4y ago
      I've never used TypeScript to talk to a database but there might be tooling to generate classes from tables. Even if there isn't, manually keeping some TypeScript classes in sync might still be worth the effort, for being able to manage schema migrations easily elsewhere.
    - dnadler 4y ago
      We do this manually along with a pydantic as a middleman between Django and TS. Works pretty well and is not a major inconvenience to keep things aligned.
    - anileated 4y ago
      Can introspect and export Django models to JSON schema or similar, then in TS read it and use compiler low-level API to generate types. There may be libraries for either stage…
switch007 4y ago
Apps should be buried deep in the documentation in some “super advanced” section and not advocated much at all
rowanseymour 4y ago
> You can make subdirectories without making apps, and thus avoid dependency hell. It's hard to get 100% right and thus our projects always have a few lazy foreign key relationships and inline imports to avoid cyclical imports... but I think our code is easier to manage because we try to model the dependency relationships by having things in separate apps. > Also be wary of the formerly South, now built-in migrations stuff Our experience from South to 4.x has been that the models/migrations system has matured significantly and is probably now the main selling point for Django for us.
- cjohnson318 4y ago
  I'm currently in circular import hell. My business logic has Jobs and Loads, and they both need to update each other under certain circumstances. Should these two things/monstrosities be lumped into the same app?
  - hbrn 4y ago
    The short answer is yes. The long answer is if two entities are updating each other you might benefit from shifting all update responsibilities to one of them. Or even to a third entity that knows about both and keeps those two isolated from each other.
    - cjohnson318 4y ago
      Woof. Thank you so much. I like the idea of a third party, like a mediator. Would that mediator be another app? Or should it be some module sitting in the project directory? (I'm not even sure Django would import something like that.)
      - hbrn 4y ago
        > Would that mediator be another app? Yes! It is an app that might not even have any model classes. But it will contain business logic. And it will probably speak domain language, which is great. If you're lucky, those two other apps will become pluggable. You will probably never replace them, but separation of concerns is always nice. The downside of course is that you will have 3 apps instead of 1. That's the balance you have to maintain.
rglullis 4y ago
> Always keep your models slim. As simple as possible, but no simpler. Django models are meant to deal not just with the data, but also with business logic. If `course.has_finished` is a property of the course, why would you want to have a separate function outside of the class? > Do precomputation if you need the information in a template If the precomputation is only needed in a template, you can (should, IMO) use template tags. > Don't make separate apps in the same project (...) avoid dependency hell. My current pattern here has been to create one "core" project where I represent all the internal models of the domain of the application, and "adapter" apps if I want to interface/integrate with anything from the external world. This makes it easier to extend or replace third-party tools. > (Migrations) It's built around a fragile model. I wouldn't call it fragile, quite the opposite. There are some annoying limitations for sure (I didn't find a reliable way to change the primary key of a model, except for creating a whole new model and migrating the data to it), but I think they are due to a matter of strong safety that the migration can only be done if it consistent.
- well1912 4y ago
  At my current company, we've had many teams over the years fail to make business logic in model methods work, and I think many other people have had similar results. The issues usually boil down to some combination of "business logic is too coupled to the data model" and "this method lives at an intersection of these two models and creates weird dependency problems". I now feel that Django puts you down a path for failure by naming the DB layer "models" and not giving users a decent place to put cross-model domain logic. My current preference is a functional core-imperative shell-style architecture where as much code lives in the functional core as possible. It's not very elegant with Django but it works fine. Cosmic Python (really accessible and fairly quick read if you have the time: https://www.cosmicpython.com/book/preface.html https://www.cosmicpython.com/book/preface.html) has examples that are similar.
  - rglullis 4y ago
    > The issues usually boil down to some combination of "business logic is too coupled to the data model" and "this method lives at an intersection of these two models and creates weird dependency problems". Refactor is not a dirty word. The problems you are describing seem to be more of the nature of having too many things concentrated at specific model classes, and that this model should be decomposed, broken down. This is not a Django-specific issue.
yiiii 4y ago
> Always keep your models slim. At least never put your business logic in your views, forms or even templates.
- collyw 4y ago
  I am in more or less in agreement, except for forms. Surely some validation could be considered business logic.
dec0dedab0de 4y ago
Always keep your models slim. Don't stuff template ...course_has_finished(course) is not much longer than course.has_finished() I disagree with this. When trouble shooting or expanding code it is super convenient to import a model and have all of your methods on auto complete. Especially when you need the same functionality in a view, a cron job, a celery task, and an DRF end point. If you want to keep it clean you can put all your methods in a mixin class and import it from another file. Also be wary of the formerly South, now built-in migrations stuff. Things are much better than they were in South. But yes be careful, rule of thumb is always move forward. Don't use class-based views Please. For the love of God, always use class based views for almost everything. Almost everything you need is a variant of one of the built in class based views, don't make me read your copy/pasted reimplementation of it.
- cjohnson318 4y ago
  > Please. For the love of God, always use class based views for almost everything. This. 100%. Leverage as much pre-built stuff you can, especially with something as important as your HTTP layer. Whenever I run out of CRUD verbs for a model and I need to add a custom endpoint, I'll implement it in a separate APIView sublcass. Convention over configuration; write boring code.
- asalahli 4y ago
  In my view (hehe), Django's class based views is a good idea implemented poorly. In theory you should be able to use any of the built-in class based generic views with minimal customizations to suit your needs, except when you want to do such customizations you're left dealing with a huge inheritance tree of mixins. It's all magic unless you know or wanna read the documentation on what each mixin brings to the view, that is _if_ you know what mixins are involved exactly, of course.
  - collyw 4y ago
    Are you aware of https://ccbv.co.uk/ https://ccbv.co.uk/? After I discovered that, class based views became easy.
collyw 4y ago
I disagree with almost everything you have said. Fat models think controllers is the suggested strategy. It works well in my opinion / experience, though I guess it could get out of hand on very large projects. There is something that feels very unnatural and unintuitive about your course_has_finished(course) versus course.has_finished() example. This was one of the principles behind OOP, keeping your data and functions / methods together, though I know OOP isn't trendy these days. It's far more natural to have it as a method of course than some random function, stored who knows where. I worked on a system with this type of design, it was pretty bad. One thing I would like to see for larger projects is the ability to easily split models into separate files - a bit more like Java does with one class per file. Maybe you can do this already. Class based views mean that a lot of code is written and tested for you. I'll agree that your view does need to be somewhat "standard" in what it's doing (anything you would see in the admin, list, create, edit, detail, login, etc), so if you have something more complex multiple forms in one view, then thy don't give a great deal of advantage. In that situation I would still likely choose a basic View class over functional views, but more for consistency. I am probably in agreement on separate apps. Migrations are one of the best features of Django. I have just spent 4 years working on a a system without them and it was a shambles as you would expect. Everyone is scared to make database changes, so you get a ton of shitty application code to compensate for shitty database modelling. Tech debt in other words. I can't think of any 3rd party apps where I have used the models directly, or if I did it was frictionless enough for me not to remember. So no real opinion on that one. 3rd party apps can be pretty hit and miss, especially if they get abandoned as you upgrade Django, so I would say use with caution, particularly for more obscure ones (just been revisiting django-celery-beat, that's been around for years so I doubt it's going away).
__pache__ 4y ago
how is this possibly the highest upvoted thing here on django. it's like the opposite of good opinions.. they're bad opinions! _(99% kidding, but i disagree with most of this lol)_

deleted 4y ago

[deleted]

j4mie 4y ago

I've been heavily inspired by this styleguide over the years, but I still think it's a bit too complex. A few random thoughts: - I think "services" is too much of a loaded term. I prefer "actions", and I always use the function-based style. - I hate the naming of "APIs" in this document. They use the term "API" when they mean "endpoint" or "view". - "Reuse serializers as little as possible" is the single best piece of advice when using DRF. The inline InputSerializer thing is brilliant. - Having each each endpoint only handle a single HTTP verb is brilliant. - URLs and views should be separate from all other business logic (models, actions etc). - For read endpoints and associated business logic, I'd encourage https://www.django-readers.org/ (disclaimer: I'm the author).

miketery 4y ago
> "Reuse serializers as little as possible" is the single best piece of advice when using DRF. The inline InputSerializer thing is brilliant. Can you expand on this? What is the InputSerializer as opposed to custom rest serializers?
- hbrn 4y ago
  I think the idea is that instead of thinking "here's the object I'm serializing" you should think "here's the view (endpoint) I'm serializing for". Contrary to what people usually think, the shape of the serialized object is typically defined by the API endpoint, not by the object itself. Different endpoints can (and will) serve different shapes of the same object. Even if two endpoints serve the same shape today, they can deviate tomorrow. When this happens, most people are trying to resolve it through DRF inheritance, which is wrong.
collyw 4y ago
After 20 years in this industry I firmly believe that the code reuse thing is way oversold in universities. It seems to be the reason for so much crappy over engineered monstrosities. YAGNI and KISS are far better things to aim for. Avoid duplicate code, but don't start out aiming for reusable code, when most of the time your requirements won't be especially clear.

greenSunglass 4y ago

I've been working on a project with flask + sqlalchemy. I have those sql queries returning a bit of rows (up to 20k) and that are quite slow. SQLalchemy does not seem to support caching the results and I've started to use flask-caching[1] with redis using the @cache.memoize() decorator. Just wondering if I am taking the right path or if there is better alternative. [1]https://flask-caching.readthedocs.io https://flask-caching.readthedocs.io

Frotag 4y ago
I've been using nginx for caching when the response isn't user-specific. Pretty painless to set up and doesn't bloat the codebase. (But it's mostly for small personal projects, so grain of salt and all.) https://www.nginx.com/blog/nginx-caching-guide/ https://www.nginx.com/blog/nginx-caching-guide/
zhte415 4y ago
Indexed? If complex, what does Sqlalchemy output as the SQL? Could you optimise the query? If quite complex, optimise the tables by redesigning them? Was the move to allow Redis to cache persistently across requests? Does it do this? Are you timing each function to look for slowness?
biorach 4y ago
> flask-caching[1] with redis using the @cache.memoize() decorator. > Just wondering if I am taking the right path or if there is better alternative. Yes, this can be a fine solution to slow queries and is used very often in many kinds of web applications. However... 20k rows is not a very big number for a modern dB. If the db query is really the slow part then you should investigate why - ensure the relevant sql queries are written properly, and that the relevant tables are indexed properly for the queries that you are running on them.

hbrn 4y ago

Ah, the typical "where to put business logic in Django". M in ActiveRecord MVC web frameworks is deeply misunderstood. M is not "data model" (it would be called DVC if that was the case). M is your domain model. It's the model of your business, model of the real world. It's the core of your application. Another thing that I never understood, why are functions called services? Is it a subconscious desire to go back to enterprisey kingdom of nouns? (apparently it is [1]) A service is either something that lives on a network (e.g. database, payment gateway, microservice). Or a class that has a state. Your functions are neither of those, they are just functions. You business logic should live in the "models" namespace. Whether you put it on Model classes, or onto custom Managers, or just dump them into the module is not important, as long as you keep it consistent and keep your apps fairly small and isolated from each other. Django already gives you enough tools to support big "enterprise" applications. It is far from perfect, but you'll get much further if you embrace the framework instead of fighting it. If you really are attached to this "services" mindset then Django API Domains [2] is your best option. [1] https://www.b-list.org/weblog/2020/mar/16/no-service/ https://www.b-list.org/weblog/2020/mar/16/no-service/ [2] https://github.com/phalt/django-api-domains https://github.com/phalt/django-api-domains

roflyear 4y ago
I never understood why this was so hard or why people complicate this so much. You have a segment of your application that "does stuff" - some mix of classes and functions. This stuff has its own API. Then you have your web views call that code through that API (which is probably just calling functions...). No, instead, it is that "does stuff" hast to be its own library, or god forbid, its own service that lives somewhere else, with its own communication layer, its own auth... Why are we making this so hard on ourselves?
- hbrn 4y ago
  Typically it goes like this: 1. You found one case where complexity is essential. 2. That one case is not consistent with the rest of your app, and you were taught that inconsistency is bad. 3. Since you can't remove complexity from that case, for the sake of consistency you add complexity to all other cases. Class-based views is a typical example. You found a place where CBVs are useful. Now some parts of your app use functions, some use classes, that's inconsistent. Edit your style guide to enforce CBV everywhere. Now a simple healthcheck endpoint that returns "OK" has to be a class. As some folks used to say, you can write Java in any language. The right approach, of course, is to say "I'd rather have inconsistency than complexity". The challenge is that perception of complexity is subjective, but inconsistency is objective. So the right approach eventually loses, and every organization turns into a bureaucratic hell.

cproctor 4y ago

I've found it helpful in several projects to implement the "services layer" described here as a state machine, modeling state transitions for a central object (e.g. an article can be drafted, submitted, reviewed, published). The state machine enforces permissible transitions and handles side effects which touch other models.

spapas82 4y ago

In a similar fashion, for anybody interested I've written some of my guidelines on implementing Django apps: https://www.spapas.net/2022/09/28/django-guidelines/ https://www.spapas.net/2022/09/28/django-guidelines/

zenith035 4y ago

Don't create apps just for the sake of project structure even when models from multiple apps are closely related. Moving models from one app to another is doable but it is a pain. It's even worse if you are relying on GFKs.

chairmanwow1 4y ago

HN comments are really disparaging, but after reading through I really liked the content and am going to pull out their service / serializer model to use in my project. Nice opinionated way to avoid structuring a program in a bad way.

theptip 4y ago

On testing, I think "one file & class per thing-to-test" is subtly bad advice. It's not harmful in the hands of someone that knows what they are doing, but it tends to point engineers towards a tightly-coupled test suite, which ends up making refactoring more painful and error prone down the road. If you have one testclass per entity, then if you make any changes to the structure of your services/models/entities, you must restructure your tests too. This means you can't do the "dream refactor" where you don't touch your tests, and restructure your code without changing any behavior. If you rewrite your tests whenever your structure changes, how can you be sure you've not broken your tests? Instead, I advocate for testing behaviors. In a tightly-integrated framework like Django, most of your tests are going to be integration tests (i.e. you have a database involved). You should bias those tests towards an integration-y approach that uses the public interfaces (Service Layer, if you have one) and asserts behavior. Ideally the tests should not change if the business logic has not changed. (In practice you'll often need to add some mapping/helper/setup code to make this true.) If you have any fat-model type behavior that is explicitly scoped to a single model, then you can test that in isolation. Many Django projects call these "unit tests" even though they still involve reading and writing your model from the DB. I call them "focused integration tests". All that matters is that you have agreement on terminology inside your project. If you have extremely complex domain logic, it can be worthwhile to construct "true Unit Tests" that use dummy objects to test logic without hitting your DB. I've not found it worthwhile to mock the DB in most Django projects though. To provide an example of where my "test behaviors not classes" advice differs from the OP's paradigm, let's say you split out a sub-object to provide a pluggable Strategy for a part of your Model's behavior -- you don't necessarily need to have detailed tests for that Strategy class if it's fully covered by the model's tests. Only the edge cases that are awkward to test at the higher level need to be tested at the granular level of the Strategy. Indeed, the first refactor that just creates a Strategy holding your existing behavior need not change any of your existing tests at all! Indeed, if you do need to change existing tests, that suggests your tests were improperly-coupled to the code under test, since a mere structural change like this should not affect the behavior of your application. Even after adding more Strategy logic, most of your old ModelTests are still good; they still test the high-level behavior, and now also test the integration between your model and the new Strategy class. Basically, test at the most-granular level that gives a clear, decoupled test for your behavior; resist testing every entity in isolation, because some entities have rich coreographies with other entites that make them hard to isolate. Sometimes you have to contort and tightly-couple in order to test things at the very-lowest-level possible. Inspiration/further reading: https://blog.cleancoder.com/uncle-bob/2017/10/03/TestContravariance.html https://blog.cleancoder.com/uncle-bob/2017/10/03/TestContrav.... (Grit your teeth through the "Socratic dialog" style. The principle being described is extremely valuable.)

OgAstorga 4y ago

Somewhat off-topic but django is fundraising over here https://www.djangoproject.com/fundraising/ https://www.djangoproject.com/fundraising/

KyeRussell 4y ago

I have a long-running thread on the Django forums with a bunch of opinions about this topic: https://forum.djangoproject.com/t/structuring-large-complex-django-projects-and-using-a-services-layer-in-django-projects/1487 https://forum.djangoproject.com/t/structuring-large-complex-...

Rastonbury 4y ago

I found this useful being someone who was self taught django and hacked together a project with no idea of architecture. To this day I don't even know what a selector is referring to lol never used it I'm learning node now for another mini project, is there anything similar? I know how it achieve certain tasks but to structure in a proper way I know nothing, all tutorials I've done never really go that deep

radoslav_ 4y ago

Hello everyone, Radoslav here (one of the authors of the mentioned Django Styleguide). First of all - I want to thank everyone to the comments The fact that someone took the time to read the styleguide & then write a comment / propose a different POV - is humbling. I've read everything once & I'll do so at least couple more times. There are interesting ideas & comments that we can apply! And finally, I want to add some more context: 1. That particular styleguide has served us, and it's still serving us well. It's basically a list of ideas that we found useful, thanks to the various Django projects that we've been exposed to at HackSoft. 2. One core philosophy of the style guide is the ability to cherry-pick whatever makes sense to you. Even at our company, it's very rare to have 2 Django projects following the exact same structure. The styleguide is rather a framework / direction for things that's been proven to work, from our experience. 3. And of course, the styleguide can use some more love from us. We are sitting on a lot of unshared knowledge that needs to be structured and applied back to the Django Styleguide & the corresponding Django Styleguide example project. 4. We try to keep it pragmatic, so you can actually build something. For example, DDD sounds great, but lacks pragmatism and slows you down by a lot (at least, for us). 5. And finally - this is not the "only right way" to do Django. As there is no "right way" to build software. Luckily, there are always options. We'll update the list of other suggested approaches, so people can have a choice / navigate the space better. As an example of one of the big topics that we want to touch upon is nesting apps. Alongside the "services / selectors" layer (btw - you can call this whatever suits you best ), the ability to nest apps within apps is really powerful, when it comes to the structure and longevity of a Django project. Having 50+ flat apps is not the best experience. Our current focus is around building the company (HackSoft). The Django Styleguide will be soon to follow. We are slowly gaining more speed & we'll eventually get there All discussion around "How to do Django" are in fact really interesting. If we happen to meet at some future EuroPython / DjangoCon Europe - I'm always open to discuss in person. Otherwise, if you have specific comments / suggestions - you can submit it either as an issue / discussion, or just send an email to radorado@hacksoft.io Cheers!

radoslav_ 4y ago
By the way, we are discussing more of this in our latest podcast episode (HackCast) here - https://www.youtube.com/watch?v=9VfRaPECbpY https://www.youtube.com/watch?v=9VfRaPECbpY Cheers!

drcongo 4y ago

Can't believe they're putting `class Meta` at the bottom of models.

YPCrumble 4y ago
What’s wrong with that?
- drcongo 4y ago
  It's a pet peeve more than anything - I just hate it when I have to scroll around to find if a class is abstract or not, our team puts it at the top so that's never an issue. Having it anywhere else means it can be any arbitrary number of lines below the class definition making it harder to find.
  - deleted 4y ago
    [deleted]
  - KyeRussell 4y ago
    I’ve never worked on a Django codebase that puts Meta at the top of a model definition. Not saying that it’s the wrong hint to do, but this just feels like feigned surprise because you surely also know that it’s far from common.
    - drcongo 4y ago
      It very much was feigned surprise, though I do know a few Django devs who prefer top. I've never really understood the logic for hiding it in the middle or at the bottom even though both are much more common.
- yiiii 4y ago
  The official coding style guide lines already state that it should come immediately after the fields. https://docs.djangoproject.com/en/dev/internals/contributing/writing-code/coding-style/#model-style https://docs.djangoproject.com/en/dev/internals/contributing...

andybak 4y ago

> We use Celery for the following general cases: > > Communicating with 3rd party services (sending emails, notifications, etc.) > Offloading heavier computational tasks outside the HTTP cycle. > Periodic tasks (using Celery beat) Sigh. No mention of the trade-offs. There's simpler ways to do all these things. Celery is a big complex beast and it always pains me to see it as the default suggestion for simple tasks.

andrewingram 4y ago
I've been using the beta of Temporal's Python SDK with Django, and aside from some minor teething issues, it's very nice.
69Represente 4y ago
I have a bug with celery i can't solve. when I send an async job that get data from various APIs and write all in a DB, in the case of lot there is lot of data, the celery task finish properly to but my flask app becomes unresponsive. I have to restart flask to get back to a normal state. Anyone would know where I should check?
- roflyear 4y ago
  sounds like a resource issue, maybe you are opening application contexts and not handling them properly?
aequitas 4y ago
A lot of people use Django with uWSGI, which also comes with queues, cron, workers, cache and lots more. I've been stuck with Celery on previous projects for reasons. But I've been dying to try out uWSGI's built in features for this. Hearing great things about it. https://uwsgi-docs.readthedocs.io/en/latest/Spooler.html https://uwsgi-docs.readthedocs.io/en/latest/Spooler.html https://uwsgi-docs.readthedocs.io/en/latest/Cron.html https://uwsgi-docs.readthedocs.io/en/latest/Cron.html https://uwsgi-docs.readthedocs.io/en/latest/Mules.html https://uwsgi-docs.readthedocs.io/en/latest/Mules.html https://uwsgi-docs.readthedocs.io/en/latest/Caching.html https://uwsgi-docs.readthedocs.io/en/latest/Caching.html