#django

I have an app where the admin interface is heavily used. There are a lot of records and the call to .distinct() for the admin filter list is very expensive. Is there any way to cache those unique values? I tried caching at the template level but the problem is the template cannot construct query parameters properly if it's cached

it's really the disinct() that is too expensive, you don't do n+1 queries?

yes, it's the distinct(). It has to do a full table scan for each filterable field

well, string fields at least

i guess you could do caching on a custom admin class?

we are talking about ``list_filter``?

yea, list_filter

well, if you look at the docs, you can for example use a custom SimpleListFilter subclass

and do whatever caching logic you want there

I will look into that, thanks

though maybe it would be worthwhile to think about not using the admin in the first place ;)

moldy: +1

yea I know, but my predecessor modified the hell out of it now people depend on it, sucks

i am guilty of that, too :p

and its 1.4!

Are there any resources for how to create generic django apps suitable for libraries

Specifically, how to handle model relations with other non generic models

frewsxcv_: this I think https://docs.djangoproject.com/en/1.9/ref/model...

frewsxcv_: not really

frewsxcv_: i am not sure what your exact question is, but it sounds a little like you are asking about "swappable" or "deferred" models

frewsxcv_: there is an unofficial / undocumented solution for this is in django, and a third-party app or two, but no clear de-facto standard

if you can somehow avoid the problem (e.g. by not defining models in your app at all), tat's the best solution ;)

Via mixing?

Mixing*

Mixins**

unfortunately it's more complicated then that

For example, I want to create a generic app for associating Tags with a model

frewsxcv_: any model?

like django-taggit?

A single model I know at runtime

one way (that has drawbacks) is to use GenericForeignKey

Not N number ofmodels at runtime

ok

maybe take a look at django-swappable. not sure how well it works at the moment.

frewsxcv_: but tags can be associated with model A and B at the same time, in the same runtime

correctw

?

Having a model builder function could maybe even work

you bascially want to do what django does wih AUTH_USER_MODEL, right?

I think so

frewsxcv_: if you answer my question we can know for sure :)

mstrcnvs: no

I don't need it to be associated with A and B

Just a known A

nice

Just like ForeignKey

so you want a swappable

it is an unsolved problem. intentionally not documented. look at django-swappable, maybe you can use it, or steal some code from them, or at the very least learn from their mistakes.

swappable ForeignKey just like AUTH_USER_MODEL like moldy said

(I'm the maintainer of taggit btw)

But this is for something unrelated to tags

i personally believe it would be great to have an official solution for this, but there is none at the moment

and why you'd give us the wrong example?

frewsxcv_: oh, that's nice :)

Just using it as an example

I'll look into django-swappable, thanks

Just using it as an example

if it's not for tags, why say tags...

It got the point across didn't it 😀

Real usage is a little more complicated and not worth going into details

Hm. This django-swappable-models looks like it'll work. Unfortunate there's not an official solution, but so be it

Does anyone have an example of doing A/B testing in Django? or doing feature flags so a portion of your audience gets beta functionality?

going to need runtime algorithm substition some time soon and would like to do a little reading

frewsxcv_: /aw

oops

frewsxcv_: for example, if your app can provide a view with a get_model() or get_object() hook, and maybe some other hooks, then maybe you can write your app without accessing the django model layer at all, and delegate all that to your users

frewsxcv_: totally depends on what your app is about, obviously