def get_queryset(self): query = self.request.GET.get("q") vector = SearchVector('tags', weight='A') + SearchVector( 'title', weight='B') + SearchVector( 'keywords', weight='C') + SearchVector('tokens', weight='D') query2 = SearchQuery(query) object_list = Document.objects.annotate( distance=TrigramDistance('tokens', query2)).filter( distance__lte=0.3).order_by('distance') object_list = Document.objects.annotate(search=SearchVector( 'title', 'keywords', 'tokens'), ).filter(search=SearchQuery(query)) object_list = Document.objects.annotate(rank=SearchRank( vector, query2, cover_density=True)).order_by('-rank') return object_list
def test_cover_density_ranking(self): not_dense_verse = Line.objects.create( scene=self.robin, character=self.minstrel, dialogue=( 'Bravely taking to his feet, he beat a very brave retreat. ' 'A brave retreat brave Sir Robin.')) searched = Line.objects.filter(character=self.minstrel).annotate( rank=SearchRank( SearchVector('dialogue'), SearchQuery('brave robin'), cover_density=True, ), ).order_by('rank', '-pk') self.assertSequenceEqual( searched, [self.verse2, not_dense_verse, self.verse1, self.verse0], )
def search_polls(request): search_val = request.GET.get('search_val') if search_val: poll_vector = SearchVector('name', weight='A') + SearchVector('description', weight='B') poll_query = SearchQuery(search_val) poll_search_results_list = Poll.objects.annotate(rank=SearchRank(poll_vector, poll_query)).filter(rank__gte=0.3).order_by('rank') paginator = Paginator(poll_search_results_list, 10) page = request.GET.get('page') poll_search_results = paginator.get_page(page) else: poll_search_results = None return render(request, 'myvote/search_generic.html', {'results': poll_search_results, 'result_type': 'Poll', 'search_val': search_val,})
def test_ranking_with_normalization(self): short_verse = Line.objects.create( scene=self.robin, character=self.minstrel, dialogue='A brave retreat brave Sir Robin.', ) searched = Line.objects.filter(character=self.minstrel).annotate( rank=SearchRank( SearchVector('dialogue'), SearchQuery('brave sir robin'), # Divide the rank by the document length. normalization=2, ), ).order_by('rank') self.assertSequenceEqual( searched, [self.verse2, self.verse1, self.verse0, short_verse], )
def get(self, request): # parsing query params from request search_query = request.GET.get("q") limit = request.GET.get("limit") offset = request.GET.get("offset") city = request.GET.get("city") if search_query is None: return Response({ "error": True, "query": "Null" }, status=status.HTTP_400_BAD_REQUEST) if city is None: return Response({ "error": True, "city": "Null" }, status=status.HTTP_400_BAD_REQUEST) if limit is None: limit = 5 if offset is None: offset = 1 vector = SearchVector('city') + SearchVector('state') + SearchVector('address') + SearchVector('branch') \ + SearchVector('state') + SearchVector('ifsc') query = SearchQuery(str(search_query).upper()) branches = Branches.objects.filter(city=str(city).upper()).annotate(rank=SearchRank(vector, query)) \ .order_by('-rank') total_results = branches.count() n_pages = math.ceil(total_results / int(limit)) branches_limited = paginator.Paginator(branches, limit) branches_offsetted = branches_limited.get_page(offset) serializer = BranchSerializer(branches_offsetted, many=True) return Response( { "error": False, "result": serializer.data, "n_pages": n_pages, "per_page": limit }, status=status.HTTP_200_OK)
def search(self, **kwargs): if not kwargs: return self.get_queryset().all() search = kwargs.get('filter') name = kwargs.get('name') company = kwargs.get('company') days = kwargs.get('days') clients = self.get_queryset() if search: if isinstance(search, list): search = search[0] try: spelled = YandexSpeller().spelled(search) except: spelled = search options = [ option for option in spelled.split(' ') if len(option) > 1 ] vector = SearchVector('name', 'company') clients = clients.filter( Q(name__icontains=search) | Q(company__icontains=search) | Q(name__icontains=spelled) | Q(company__icontains=spelled) | Q(name__in=options) | Q(company__in=options)).annotate( rank=SearchRank(vector, search)).order_by('-rank') if name: if isinstance(name, list): name = name[0] clients = clients.filter(name__icontains=name) if company: if isinstance(company, list): company = company[0] clients = clients.filter(company__icontains=company) if days: dates = [ datetime.strptime(day, '%Y-%m-%d') for day in kwargs.get('days') ] clients = clients.filter(projects__days__date__in=dates).distinct() return clients
def search_threads(request, query, visible_threads): search_query = SearchQuery( filter_search(query), config=settings.MISAGO_SEARCH_CONFIG, ) search_vector = SearchVector( 'search_document', config=settings.MISAGO_SEARCH_CONFIG, ) return Post.objects.select_related('thread', 'poster').filter( is_event=False, is_hidden=False, is_unapproved=False, thread_id__in=visible_threads.values('id'), search_vector=search_query, ).annotate(rank=SearchRank(search_vector, search_query)).order_by( '-rank', '-id')
def search(self, search_text): search_vectors = (SearchVector('title', weight='A', config='english') + SearchVector( StringAgg('content', delimiter=' '), weight='B', config='english', )) search_query = SearchQuery( search_text, config='english', ) search_rank = SearchRank(search_vectors, search_query) trigram_similarity = TrigramSimilarity('title', search_text) return (self.filter( search_vector=search_query, is_active=True).select_related('author').select_related( 'previouspost').select_related('nextpost').annotate( rank=search_rank + trigram_similarity).order_by('-rank'))
def get_events_full_text_search(self, text_query, min_date, max_date, location, distance_max): if not text_query: return [] qs = self.get_queryset() q = PrefixSearchQuery(text_query, config="fr") qs = (qs.annotate(rank=SearchRank(F("search"), q)).filter( rank__gt=0).order_by("-rank").filter( visibility=Event.VISIBILITY_PUBLIC)) if min_date: qs = qs.filter(start_time__gt=min_date) if max_date: qs = qs.filter(start_time__lt=(max_date + timedelta(days=1))) if location and distance_max: qs = qs.annotate( distance=Distance("coordinates", location)).filter( distance__lte=DistanceMeasure(km=int(distance_max))) return qs
def post_search(request): form = SearchForm() query = None results = [] if 'query' in request.GET: form = SearchForm(request.GET) if form.is_valid(): query = form.cleaned_data['query'] search_vector = SearchVector('title', weight='A') + SearchVector('body', weight='B') search_query = SearchQuery(query) results = Post.objects.annotate( rank=SearchRank(search_vector, search_query) ).filter(rank_gte=0.3).order_by('-rank') return render(request, 'blog/post/search.html', { 'form': form, 'query': query, 'results': results })
def article_search(request): template_name = 'my_site/search.html' search_form = SearchForm() query = None results = [] if 'query' in request.GET: search_form = SearchForm(request.GET) if search_form.is_valid(): query = search_form.cleaned_data['query'] search_vector = SearchVector('title', 'content') search_query = SearchQuery(query) results = Article.objects.annotate( search=search_vector, rank = SearchRank(search_vector, search_query) ).filter(search=search_query).order_by('-rank') context = {'search_form': search_form, 'results': results, 'query': query} return render(request, template_name, context)
def search(request): results = [] if 'keywords' in request.GET: keywords = request.GET['keywords'] if keywords: search_vector = SearchVector('nickname', 'description', 'owner', 'patient_type') search_query = SearchQuery(keywords) results = ClinicPatients.objects.annotate( search=search_vector, rank=SearchRank(search_vector, search_query)).filter( search=search_query).order_by('-rank') context = { 'patients': results, } return render(request, 'pages/search/search.html', context)
def article_search(request): form = SearchForm() query = None result = [] if 'query' in request.GET: form = SearchForm(request.GET) if form.is_valid(): search_vector = SearchVector('title', weight='A') + \ SearchVector('body', weight='A') + \ SearchVector('author', weight='A') query = form.cleaned_data['query'] search_query = SearchQuery(query) result = Article.published_article.annotate( search=search_vector, rank=SearchRank(search_vector, search_query)).filter(rank__gte=0.3) \ .order_by('-rank') return render(request, 'articles/search.html', {'form': form, 'query': query, 'result': result})
def index(request): results = [] query = request.GET.get("q") if query: # url and title have the main weights vector = SearchVector( 'title', weight='A', config="german") + SearchVector( 'website__url', weight='A', config="german") + SearchVector( 'description', weight='B', config="german") search_query = SearchQuery(query, config="german") results = Feed.objects.annotate( rank=SearchRank(vector, search_query)).filter( rank__gte=0.3).order_by('-rank') return render(request, "index.html", { 'query': query, 'results': results, })
def post(self, request, *args, **kwargs): voice_input = request.data.get('voice_input') if not voice_input: return Response({'error': 'No voice input'}, status=status.HTTP_400_BAD_REQUEST) if self.kwargs.get('platform') not in ['alexa', 'google', 'bixby']: return Response({'error': 'Unsupported voice platform'}, status=status.HTTP_400_BAD_REQUEST) search_vectors = SearchVector('categories__name', weight='A', config='english') search_query = SearchQuery(voice_input, config='english') search_rank = SearchRank(search_vectors, search_query) narrs = Narration.objects.filter(library=True).annotate(search=search_vectors).filter(search=search_query).annotate(rank=search_rank).distinct('id', 'rank').order_by('-rank', 'id') if narrs: return Response(VoiceItemSerializer(narrs, many=True, context={'platform': self.kwargs.get('platform')}).data) else: raise Http404('No narrations found')
def full_text_search(request): #Функция поиска ''' :param request: localhost:8000/main/search?search=text :return: [{"id": 2, "PID": 2, "CID": 2, "psource": "gmail", "typedoc": "text", "metadata": "text,im", "data_main": "qwqwqwq", "additional_data": "asss", "link": null}] ''' res = Data.objects.filter() search_term = request.GET.get('search', '') #res = Data.objects.filter(typedoc__search=search_term) query = SearchQuery(search_term) title_vector = SearchVector('metadata', weight='A') content_vector = SearchVector('typedoc', weight='B') vectors = title_vector + content_vector res = res.annotate(search=vectors).filter(search=query) res = res.annotate(rank=SearchRank(vectors, query)).order_by('-rank') serializer = DataSerializer(res, many=True) return JsonResponse(serializer.data, safe=False)
def search(request): if 'query' in request.GET: form = SearchForm(request.GET) if form.is_valid(): query = SearchQuery(request.GET['query']) vector = SearchVector('title', weight='A') + SearchVector('author', weight='A') + \ SearchVector('body', weight='B') results = Note.objects.annotate( rank=SearchRank(vector, query)).filter( rank__gte=0.3).order_by('-rank') if results: paginator = Paginator(results, 12) page_number = request.GET.get('page') page_content = paginator.get_page(page_number) context = {'notes': page_content} return render(request, 'notes/note_list.html', context) else: return render(request, 'notes/not_found.html')
def post_search(request): if 'query' in request.GET: form = SearchForm(request.GET) if form.is_valid(): query = form.cleaned_data['query'] # results = Post.published.annotate(search = SearchVector('title','body')).filter(search=query) search_vector = SearchVector('title','body') search_query = SearchQuery(query) results = Post.published.annotate( search=search_vector, rank=SearchRank( search_vector, search_query)).filter(search=search_query).order_by('-rank') else: form = SearchForm() query = None results = [] return render(request, 'blog/post/search.html', {'form': form, 'query': query, 'results': results})
def search(request): # Full text search for records matching text results = None if (request.GET.get("text") is not None): query = SearchQuery(request.GET.get("text")) rank = SearchRank(F("tokens"), query) posts = Post.objects.annotate(rank=rank).filter( tokens=query).order_by("-rank") # topics = Topic.objects.annotate(rank=rank).filter(tokens=query).order_by("-rank") page = request.GET.get('page', 1) paginator = Paginator(posts, 20) results = paginator_catch_exceptions(page, paginator) return render(request, "site/search/search.html", context={"results": results})
def get_queryset(self): """ Get the User's Notes ordered by ranking with given search query. Implements a full-text search on the fields: `title` and `content`. """ search_query = self.get_search_query() if search_query is not None: user = self.request.user # Log search query. SearchHistory.objects.create(user=self.request.user, query=search_query) # Return search results vector = SearchVector('title', 'content') query = SearchQuery(search_query) results = Note.objects.filter(user=user).annotate( rank=SearchRank(vector, query)).order_by('-rank')[:12] return results return
def get_queryset(self): qs = Setup.objects.all() keywords = self.request.GET.get('q') if keywords: query = SearchQuery(keywords) title_vector = SearchVector('name', weight='A') car_sub_model_vector = SearchVector( 'sub_model_setup__car_model__brand__name', 'sub_model_setup__car_model__name', 'sub_model_setup__name', weight='B') content_vector = SearchVector('description', weight='D') vectors = title_vector + car_sub_model_vector + content_vector qs = qs.annotate(search=vectors).filter(search=query) qs = qs.annotate(rank=SearchRank(vectors, query)).order_by('-rank') return qs
def search_user(self, request): vector = SearchVector('first_name', weight='A') + SearchVector( 'last_name', weight='B' ) + SearchVector( 'city', weight='C' ) query = SearchQuery(request.GET.get('q', None)) search_result = User.objects.annotate(rank=SearchRank(vector, query)).order_by( '-rank' ) page = self.paginate_queryset(search_result) if page is not None: serializer = self.get_serializer(page, many=True) return self.get_paginated_response(serializer.data) serializer = self.get_serializer(search_result, many=True) return self.get_paginated_response(serializer.data)
def filter_queryset(self, request, queryset, view): if request.user.is_superuser or request.query_params.get("all") == "true": pass elif request.user.user_type >= User.TYPE_VALUE_MAP["DistrictLabAdmin"]: queryset = queryset.filter(district=request.user.district) else: queryset = queryset.filter(Q(created_by=request.user) | Q(users__id__exact=request.user.id)) search_text = request.query_params.get("search_text") if search_text: vector = SearchVector("name", "district__name", "state__name") query = SearchQuery(get_psql_search_tokens(search_text), search_type="raw") queryset = ( queryset.annotate(search_text=vector, rank=SearchRank(vector, query)) .filter(search_text=query) .order_by("-rank") ) return queryset
def search(self, search_text): search_vectors = ( SearchVector('article_abstract', weight='A', config='english') + SearchVector( StringAgg('keyword_list', delimiter=';'), weight='B', config='english', )) search_query = SearchQuery(search_text, config='english') search_rank = SearchRank(search_vectors, search_query) trigram_similarity = TrigramSimilarity('article_abstract', search_text) qs = (self.get_queryset().filter(search_vector=search_query).annotate( rank=search_rank + trigram_similarity).order_by('-rank')) return qs
def search(self, folders=False, without_folders=False, **kwargs): search = kwargs.get('filter') days = kwargs.get('days') if folders: projects = self.folders() elif search or days or without_folders: projects = self else: projects = self.exclude( Q(parent__isnull=False) & Q(creator=F('user'))).without_children() if search: if isinstance(search, list): search = search[0] try: spelled = YandexSpeller().spelled(search) except: spelled = search options = [ option for option in spelled.split(' ') if len(option) > 1 ] vector = SearchVector('title', 'client__name', 'client__company') projects = projects.filter( Q(title__icontains=search) | Q(client__name__icontains=search) | Q(client__company__icontains=search) | Q(parent__title__icontains=search) | Q(title__icontains=spelled) | Q(client__name__icontains=spelled) | Q(client__company__icontains=spelled) | Q(parent__title__icontains=spelled) | Q(title__in=options) | Q(client__name__in=options) | Q(client__company__in=options) | Q(parent__title__in=options)).annotate( rank=SearchRank(vector, search)).order_by('-rank') if days: dates = [ datetime.strptime(day, '%Y-%m-%d') for day in kwargs.get('days') ] projects = projects.filter(days__date__in=dates).distinct() return projects
def posts(request): search = request.GET.get("q") page = request.GET.get("page") if page is None and not search: return redirect(get_link(1, search)) page = int(page or 1) limit = DEFAULT_LIMIT offset = (page - 1) * limit if not search: posts = Post.objects.all() else: vector = SearchVector('text', weight='A') + SearchVector('title', weight='B') query = SearchQuery(search) posts = Post.objects.annotate(rank=SearchRank(vector, query)).filter( rank__gte=0.3).order_by('rank') count = len(posts) posts = posts[offset:offset + limit] pages = math.ceil(count / limit) previous_page = False next_page = False if page > 1: previous_page = get_link(page - 1, search) if page < pages: next_page = get_link(page + 1, search) pages_links = { x + 1: { "link": get_link(x + 1, search), "disabled": False } for x in range(pages) } if page in pages_links: pages_links[page]["disabled"] = True return render(request, 'posts.html', context={ "posts": posts, "previous_page": previous_page, "next_page": next_page, "pages": pages, "pages_links": pages_links, })
def get_queryset(self): self.products = [] form = HomeProductSeachForm(self.request.GET) if form.is_valid(): product = form.cleaned_data['product'] try: print('LENGTH',len(product)) except: product = "" try: category = self.request.GET['category'][0] len(category) except: category='' try: status = self.request.GET['status'][0] len(status) except: status = '' search_vector = SearchVector('name', config='french', weight='A') + SearchVector('description', config='french', weight='B') search_query = SearchQuery(product) if ( len(product) & len(status) & len(category)): query_products = Product.show.filter(status = status, category__id=category).annotate(search= search_vector, rank=SearchRank(search_vector, search_query)).filter(search=search_query).order_by('-rank') elif(len(product) & len(status)): query_products = Product.show.filter(status = status).annotate(search= search_vector, rank=SearchRank(search_vector, search_query)).filter(search=search_query).order_by('-rank') elif(len(product) & len(category)): query_products = Product.show.filter(category__id=category).annotate(search= search_vector, rank=SearchRank(search_vector, search_query)).filter(search=search_query).order_by('-rank') elif(len(status) & len(category)): query_products = Product.show.filter(status = status, category__id=category) elif len(product): query_products = Product.show.annotate(search= search_vector, rank=SearchRank(search_vector, search_query)).filter(search=search_query).order_by('-rank') print("INSIDE PRODUCT") elif len(status): query_products = Product.show.filter(status = status) elif len(category): query_products = Product.show.filter(category__id = category) else: query_products = Product.show.all() self.products = query_products return self.products
def post_search(request): # Instantiate the SearchForm form form = SearchForm() query = None results = [] # To check whether the form is submitted, you look for the query parameter # - in the request.GET dictionary. if 'query' in request.GET: # send the form using the GET method instead of POST, so that the resulting # - URL includes the query parameter and is easy to share. form = SearchForm(request.GET) # When the form is submitted, you instantiate it with the submitted GET data, and # - verify that the form data is valid. if form.is_valid(): query = form.cleaned_data['query'] # If the form is valid, you search for published posts with a custom # - SearchVector instance built with the title and body fields. # -- apply different weights to the search vectors built using the title and body fields search_vector = SearchVector('title', weight='A') + SearchVector( 'body', weight='B') # Create a SearchQuery object, filter results by it, and use SearchRank to # - order the results by relevancy. search_query = SearchQuery(query) results = Post.published.annotate( search=search_vector, rank=SearchRank(search_vector, search_query) # Filter the results to display only the ones with a rank higher than 0.3. ).filter(rank__gte=0.3).order_by('-rank') # Another search approach is trigram similarity. A trigram is a group of three consecutive characters. # - You can measure the similarity of two strings by counting the number of trigrams that they share. # - This approach turns out to be very effective for measuring the similarity of words in many languages. # - Searching for 'yango' will give you 'django' results # replace results fields with: # # results = Post.published.annotate( # similarity=TrigramSimilarity('title', query), # ).filter(similarity__gt=0.1).order_by('-similarity') return render(request, 'blog/post/search.html', { 'form': form, 'query': query, 'results': results, })
def post_search(request): form = searchForm() query = None results = [] if 'query' in request.GET: form = searchForm(request.GET) '''GET method so that the resulting URL includes the query parameter. To check whether the form is submitted, we look for the query parameter in the request.GET dictionary.''' if form.is_valid(): query = form.cleaned_data['query'] # results = POST.objects.annotate( # search = SearchVector('title', 'body'), # ).filter(search=query) '''replace the above code with''' '''we created a SearchQuery object, filtered results by it, and used SearchRank to order the results by relevancy''' # search_vector = SearchVector('title', 'body') # search_query = SearchQuery(query) # results = POST.objects.annotate( # search = search_vector, # rank = SearchRank(search_vector, search_query) # ).filter(search= search_query).order_by('-rank') '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' '''3rd weighing queries''' sector_vector = SearchVector('title', weight='A') + SearchVector('body', weight='B') search_query =SearchQuery(query) results = POST.objects.annotate( rank = SearchRank(sector_vector, search_query) ).filter(rank__gte=0.3).order_by('-rank') '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' '''Using trigram similarty search''''' # results = POST.objects.annotate( # similarity=TrigramSimilarity('title', 'body'), # ).filter(similarity__gt=0.3).order_by('-similarity') return render(request, 'blog/post/search.html', {'form': form, 'query': query, 'results': results})
def product_search(qs, phrase): """Return matching products for storefront views. Name and description is matched using search vector. Args: qs (ProductsQueryset): searched data set phrase (str): searched phrase """ query = SearchQuery(phrase, config="english") vector = F("search_vector") ft_in_description_or_name = Q(search_vector=query) variants = ProductVariant.objects.filter(sku=phrase).values("id") ft_by_sku = Q(Exists(variants.filter(product_id=OuterRef("pk")))) return (qs.annotate(rank=SearchRank(vector, query)).filter( (ft_in_description_or_name | ft_by_sku)).order_by("-rank", "id"))