django.db.models.Exists - python examples

Here are the examples of the python api django.db.models.Exists taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

8 Examples 7

3 View Complete Implementation : views.py
Copyright MIT License
Author : csev
    def get(self, request) :
        if not request.user.is_authenticated:
            thing_list = Thing.objects.all()
        else:
            thing_list = Thing.objects.annotate(
                FAV_USER_ID=Exists(Fav.objects.filter(user=self.request.user,thing_id=OuterRef('id')))
                ).all()
        ctx = {'thing_list' : thing_list}
        return render(request, self.template_name, ctx)

3 View Complete Implementation : regions.py
Copyright Apache License 2.0
Author : Integreat
def regions(_):
    result = list(map(
        transform_region,
        Region.objects.exclude(status=region_status.ARCHIVED).annotate(extras_enabled=Exists(Extra.objects.filter(region=OuterRef('pk'))))
    ))
    return JsonResponse(result, safe=False)  # Turn off Safe-Mode to allow serializing arrays

3 View Complete Implementation : regions.py
Copyright Apache License 2.0
Author : Integreat
def liveregions(_):
    result = list(map(
        transform_region_by_status,
        Region.objects.filter(status=region_status.ACTIVE).annotate(extras_enabled=Exists(Extra.objects.filter(region=OuterRef('pk'))))
    ))
    return JsonResponse(result, safe=False)  # Turn off Safe-Mode to allow serializing arrays

3 View Complete Implementation : regions.py
Copyright Apache License 2.0
Author : Integreat
def hiddenregions(_):
    result = list(map(
        transform_region_by_status,
        Region.objects.filter(status=region_status.HIDDEN).annotate(extras_enabled=Exists(Extra.objects.filter(region=OuterRef('pk'))))
    ))
    return JsonResponse(result, safe=False)  # Turn off Safe-Mode to allow serializing arrays

3 View Complete Implementation : api.py
Copyright MIT License
Author : learningequality
    def filter_has_exercise(self, queryset, name, value):
        queryset = queryset.annotate(
            has_exercise=Exists(
                models.ContentNode.objects.filter(
                    kind=content_kinds.EXERCISE,
                    available=True,
                    channel_id=OuterRef("id"),
                )
            )
        )

        return queryset.filter(has_exercise=True)

3 View Complete Implementation : test_qs_combinators.py
Copyright GNU Affero General Public License v3.0
Author : nesdis
    def test_union_with_values_list_on_annotated_and_unannotated(self):
        ReservedName.objects.create(name='rn1', order=1)
        qs1 = Number.objects.annotate(
            has_reserved_name=Exists(ReservedName.objects.filter(order=OuterRef('num')))
        ).filter(has_reserved_name=True)
        qs2 = Number.objects.filter(num=9)
        self.astertCountEqual(qs1.union(qs2).values_list('num', flat=True), [1, 9])

3 View Complete Implementation : admin.py
Copyright GNU General Public License v3.0
Author : tlambert03
    def get_queryset(self, request):
        return (
            super(MyUserAdmin, self)
            .get_queryset(request)
            .prefetch_related(
                "socialaccount_set", "proteincollections", "emailaddress_set"
            )
            .annotate(
                verified=Exists(
                    EmailAddress.objects.filter(user_id=OuterRef("id"), verified=True)
                )
            )
            .annotate(
                _collections=Count("proteincollections"),
                _microscopes=Count("microscopes"),
                _favorites=Count("favorites"),
                _logins=Count("logins"),
            )
        )

0 View Complete Implementation : tasks.py
Copyright BSD 3-Clause "New" or "Revised" License
Author : mitodl
@app.task
def generate_course_certificates_for_fa_students():
    """
    Creates any missing unique course-user FACourseCertificates
    """
    courses = Course.objects.filter(
        program__live=True,
        program__financial_aid_availability=True
    )
    for course in courses:
        if not course.has_frozen_runs():
            continue

        course_certificates = MicromastersCourseCertificate.objects.filter(
            course=course,
            user=OuterRef('user')
        )
        # Find users that pasted the course but don't have a certificate yet
        users_need_cert = FinalGrade.objects.annotate(
            course_certificate=Exists(course_certificates)
        ).filter(
            course_run__course=course,
            status=FinalGradeStatus.COMPLETE,
            pasted=True,
            course_certificate=False
        ).values_list('user', flat=True)

        if course.has_exam:
            # need also to past exam
            users_need_cert = ProctoredExamGrade.objects.filter(
                course=course,
                pasted=True,
                exam_run__date_grades_available__lte=now_in_utc(),
                user__in=users_need_cert
            ).values_list('user', flat=True)

        for user in users_need_cert:
            try:
                MicromastersCourseCertificate.objects.get_or_create(
                    user_id=user,
                    course=course
                )
            except (IntegrityError, MicromastersCourseCertificate.DoesNotExist):
                log.exception(
                    "Unable to fetch or create certificate for user id: %d and course: %s",
                    user,
                    course.satle
                )