Hello.

I love the idea of this app. Wanted this/to create it for years. So, thank you.

One thing that annoy me a little is this: in the test test_many_to_one_reverse, nplusone generates a warning when selecting addresses for a user.

But I don't think it should, as doing a prefetch_related here won't change anything: we'll still have two queries, one to get the first user, and one to get the addresses (instantly if we use prefetch_related, and only when asking for addreses when not)

Sadly this prevents me to really use this lib because it can happens a lot as there is no optimization to do here, so nobody does a prefetch_related for a get (or .first() too?). Think of edit forms, detail views...

The only way to change this would be to monkey patch the get method, to not take the current queryset into action for missing prefetch_related (but still do for missing select_related).

If I use a relation (prefetched via prefetch_related in django for example) in a loop but the query returned no data, nplusone think that it's a "eager load'

It should only think this way if actual data is returned, because this causes a lot of false positive :(

Getting the error when using django.db.models.Prefetch to prefetch related through model. Error does not occur when nplusone is not in INSTALLED_APPS.

Test fails on all tox envs.

I am using django with a lot of 3d party apps, like: django-filer, django-axes, reversion, and may others. I like to be notified about potential problems with exceptions.

I would like to ignore a lot of errors inside my admin panel. But, since I can't and do not want to fix issues with 3d party plugins, I would like to ignore some urls:

• /admin/filer
• and some urls of mine

Can you consider adding such feature?

Hi, thanks for the awesome library.

Right now I try to use your library for a specific project, which includes:

1. a lot of celery tasks
2. telegram events handling via python-telegram-bot
3. a lot of existing unit tests

So, I want to raise exceptions inside these "functions" if there are any violations. But the problem is that I don't have any http requests.

So, middleware does not work here. Do you have any vision about how this library should be used in these cases? Related to https://github.com/wemake-services/wemake-django-template/issues/255

Thanks!

This fixes a few behaviors and improves the usability of the Flask extension.

• *Support factory pattern (init_app)
• Correct teardown to handle missing listeners
• Add ignore helper

Note: this isn't fully supporting the app.extensions paradigm, but it at least will function in single-app-factory applications.

Hello,

The MIDDLEWARE_CLASSES setting is deprecated in Django 1.10 and the MIDDLEWARE setting takes precedence. Projects using MIDDLEWARE cannot use the nplusone middleware

When the NPlusOneMiddleware is at the end of the list of middlewares and a previous middleware returned a response, an error occurs in NPlusOneMiddleware.process_response because the request is not the list of listeners, as the NPlusOneMiddleware.process_request was not called (because a middleware returning a response stops the execution of the process_request methods of the following middlewares)

So the NPlusOneMiddleware should be before every middleware that can return a response (or, at least, manage KeyError exceptions in NPlusOneMiddleware.process_response)

PyPI expects an OSI-specified license--not the full license text.

Just noticed this while glancing at OSF's pyup:

P.S. No idea why pyup thinks nplusone isn't Py3-compatible since the correct classifiers are set.

This adds MiddlewareMixin which is needed to use the Django mixin in the new MIDDLEWARE setting instead of the deprecated MIDDLEWARE_CLASSES. Here's the relevant Django documentation: https://docs.djangoproject.com/en/1.10/topics/http/middleware/#upgrading-pre-django-1-10-style-middleware

If the same record is loaded both singly (e.g. using one or first) and multiply, we can get false positives for lazy loads. To fix, we can ignore lazy loads on records that were loaded singly. Note that this logic could lead to false negatives, which isn't ideal--but it's less confusing than the status quo. See https://github.com/flyerhzm/bullet/blob/master/lib/bullet/active_record5.rb#L53-L56 for an example.

I don't know if this is a bug or a feature.

Using:

• Django 4.1.2
• Nplusone 1.0.0

If I delete a model that generates cascade deletions, those are displayed in the console as N+1s. For instance, in the classic Book -> Author example, if I delete an Author, the package flags N+1 like this:

Potential n+1 query detected on Book.author

Using warnings about n+1 query is more pythonic.

warnings.warn() in library code if the issue is avoidable and the client application should be modified to eliminate the warning logging.warning() if there is nothing the client application can do about the situation, but the event should still be noted

https://docs.python.org/3/howto/logging.html#when-to-use-logging

It is also convenient to use with pytest. Because pytest creates a report on all warnings. https://docs.pytest.org/en/7.1.x/how-to/capture-warnings.html

Sorry for my english.

There are some cases when in the function signalify_fetch_all the decorator is called on the already decorated function queryset._fetch_all, causing a recursion depth exception if a fetch all query is invoked many times. This also happens if the query is not actually executed but its cached result is used. The issue can be reproduced through the following Django test:

class TestTheIssue(TestCase):
    def test_n_plus_one_wrapper_error(self):
        out = []
        # MyModelA has many MyModelB, the relationship is represented adding a 
        # models.ForeignKey field on model B with related name 'my_model_bs'
        qs = MyModelA.objects.all().prefetch_related('my_model_bs').first()
        # Execute this query N times, with N any number that is bigger than the recursion limit, 
        # in my case it is sys.getrecursionlimit() = 1000 
        for i in range(2000):  
            tmp = qs.my_model_bs.all()
            out.append(tmp.first())

        print(out[-1])

Details

nplusone version: 1.0.0 Django version: 3.2.13

environment: python:3.8.9-slim-buster image for Docker

I have a quite frustrating problem. After fixing a lazyload-issue I now can't delete this model. Imagine a mixin along with its admin mixin. The ModelAdminMixin overrides get_queryset with a call to select_related; otherwise I'd get a N+1 warning when displaying the related object list or details. This however causes, that I can't delete any of these objects in the admin interface. I will get an eager loading error, wenn pressing delete or the history button of the object. How can I fix that? In the following you see a boiled down implementation of the mixins and how they are used.

class ModelMixin(models.Model):
    created_by = ForeignKey(settings.AUTH_USER_MODEL, on_delete=PROTECT, related_name="created_%(app_label)s_%(class)s")
    class Meta:
        abstract = True

class ModelAdminMixin(object):
        def get_queryset(self, request):
                return super(ModelAdminMixin, self).get_queryset(request).select_related('created_by')

They are then used in a concrete model as such:

# models.py
#------------

class ConcreteModel(ModelMixin):
    name = models.CharField(_('name'), max_length=100, blank=False, default='undefined')

# admin.py
#-----------

@register(Project)
class ConcreteModelAdmin(ModelAdminMixin, admin.ModelAdmin):
    pass