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"))
