<h4>Learn how this module can help you get richer search results, more easily, than Python’s built-in “filter” method</h4>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bs9ox6xXQXHYFkU8gw4l-A.jpeg"></figure>Originally published on my <a href="http://tomisin.dev/blog">blog</a>.
For the umpteenth time, you are having to implement a search functionality in your Python application. As a no-brainer, you turn to Python’s filter method.
Half the time, the filter method rightly serves you just fine.
But, as you increase the requirements of your “search” function, you realise that you need to put substantial effort into improving the robustness of the filter function’s results.
For instance, you’re looking to return more “interesting” (<a href="https://redis.com/blog/what-is-fuzzy-matching/">fuzzy</a>) results, say your application gives users a list of songs matching their search input, and you want the result to include songs which closely match the input, permitting spelling errors, <a href="https://pypi.org/project/huntela/">Huntela</a> is made for you.
<h3>What is Huntela</h3>
<a href="https://pypi.org/project/huntela/">Huntela</a> is a module that contains several methods that could help you get robust search results. A simple illustration
<pre>&gt;&gt;&gt; import huntela &gt;&gt;&gt; &gt;&gt;&gt; huntela.fuzzy_search(term='app', items=['app', 'apps', 'phone']) [ {'confidence': 1, 'index': 0, 'value': 'app'}, {'confidence': 0.8, 'index': 1, 'value': 'apps'} ]</pre>
Right off the bat, we notice some…
<h3>Advantages of Huntela over Python’s filter Method</h3>
<ol>
<li>
Fuzzy Matching: The fuzzy_search function uses a character comparison method that includes close matches in its results, allowing for fuzzy matching and increased flexibility in searching for similar or related terms.</li>
<li>
Confidence Values: The fuzzy_search function returns results with a confidence score that indicates the level of similarity between the search term and the matched item, providing a more precise indication of how well the search term matches the desired results.</li>
<li>
Index Values: The fuzzy_search function method also returns the index of each matching item in the original list, which can be useful for further processing.</li>
<li>
Lots of Utility Search Functions: Now, guess what! The same juiciness of the result of the fuzzy_search function applies to several other search functions the module provides. These include binary_search, search_for_least_frequent_items, search_for_most_frequent_items.</li>
<li>
Consistent Interfaces: The fuzzy_search method returns a list of Result objects representing the search results, which provide additional information such as the confidence value and index.</li>
</ol>
<h3>Ready to give Huntela a try?</h3>
Open up your favourite command line, and type in:
<pre>pip install huntela</pre>
<h3>Practical Examples With the Huntela Library</h3>
<h4>Autocorrect &amp; Text Suggestion Feature</h4>
You are tasked with returning words which closely match a user’s input. This would be a great use-case for <a href="https://pypi.org/project/huntela/">Huntela</a>.
<pre>&gt;&gt;&gt; import huntela &gt;&gt;&gt; &gt;&gt;&gt; user_input = input("Type in a word: ") # hellu &gt;&gt;&gt; &gt;&gt;&gt; vocab = ["hello", "run", "jump", ...] &gt;&gt;&gt; results = huntela.fuzzy_search(user_input, vocab) [ {"confidence": 0.8, "index": 0, "value": "hello"} ] &gt;&gt;&gt; print(f"Did you mean: '{results[0]['value']}'?") Did you mean 'hello'?</pre>
<h4>Improving User Search Experience in a Shopping Site</h4>
Suppose you are assigned to fetch products from an e-commerce platform that closely resemble the user’s input in a search query. You can achieve this by using the fuzzy_search function of the <a href="https://pypi.org/project/huntela/">Huntela</a> module.
<pre>&gt;&gt;&gt; import huntela &gt;&gt;&gt; &gt;&gt;&gt; user_input = input("What would you like to buy? ") # t-shirt &gt;&gt;&gt; &gt;&gt;&gt; store = [ {"name": "Headphones", "price": 59.99}, {"name": "Shirt", "price": 19.99} ] &gt;&gt;&gt; results = huntela.fuzzy_search(user_input, store, key='name') [ {"confidence": 0.8, "index": 1, "value": "Shirt"} ]</pre>
<h4>Searching for a specific value in a sorted list</h4>
Suppose you have a sorted list of integers, and you want to find if a specific value exists in the list. You can use binary search to do this efficiently.
<pre>&gt;&gt;&gt; import huntela &gt;&gt;&gt; &gt;&gt;&gt; results = huntela.binary_search(term=5, items=[1, 3, 4, 5, 7, 9, 11]) [ {"confidence": 1, "index": 3, "value": 5} ]</pre>
<h4>Analytics</h4>
You could also use this function to analyze large datasets and find the most and least frequent values. For example, you could use this function to find the most common search queries on a website or the most popular products purchased by customers.
<pre>&gt;&gt;&gt; import huntela &gt;&gt;&gt; &gt;&gt;&gt; site_visitor_ids = [101, 102, 103, 101, 105, 103, 101, 102, 104] &gt;&gt;&gt; &gt;&gt;&gt; most_frequent = huntela.search_for_most_frequent_items(2, user_ids) [ {'confidence': 1, 'index': [0, 3, 6], 'value': 101}, {'confidence': 1, 'index': [1, 7], 'value': 102}, {'confidence': 1, 'index': [2, 5], 'value': 103} ]</pre>
<h3>Conclusion</h3>
If you’re looking to get more robust and flexible search results than Python’s built-in filter method can provide, <a href="https://pypi.org/project/huntela/">Huntela</a> is definitely worth a try.
With its fuzzy matching, confidence values, and index values, <a href="https://pypi.org/project/huntela/">Huntela</a> can help you implement features like autocorrect and text suggestion, improve user search experiences in an e-commerce platform, and efficiently search sorted lists.
Additionally, <a href="https://pypi.org/project/huntela/">Huntela’s</a> other search functions like searching for most and least frequent items provide valuable utility for analysing large datasets. The module is easy to use and consistent in its interfaces, making it a powerful alternative to the filter method.
So why not give it a try and see how it can enhance your Python search capabilities?
<h4>Ready to give Huntela a try?</h4>
Open up your favourite command line, and type in:
<pre>pip install huntela</pre>
If you found this article helpful, clap, share and subscribe.
<hr>
<a href="https://medium.com/geekculture/maximize-your-python-search-capabilities-with-huntela-a-powerful-alternative-to-the-filter-method-5e95a80f166c">Maximize Your Python Search Capabilities with Huntela</a> was originally published in <a href="https://medium.com/geekculture">Geek Culture</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.

Learn how this module can help you get richer search results, more easily, than Python’s built-in “filter” method

Maximize Your Python Search Capabilities with Huntela

<h4>Learn how Django models could implement soft delete, without modifying the interfaces and contracts of models and querysets.</h4>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0jvWLbXENhbH5Q2b"><figcaption>Photo by <a href="https://unsplash.com/fr/@markuswinkler?utm_source=medium&amp;utm_medium=referral">Markus Winkler</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure>Originally published on my <a href="https://tomisin.dev/blog">blog</a>.
In contemporary architecture, or by design requirements, we often have the need to keep certain records even after they’ve been “deleted” by the user — that’s where soft deletion comes in.
In this article, we would learn how to implement soft delete, while our application maintains its Django-ness (for lack of a better word), and we can still maintain the same interface with our model objects in the same way as we would, if we had hard deletion in place.
<h3>What is Soft Delete</h3>
Soft delete is the process of deleting records in such a way that it is still present in the database while made unavailable to the user. It involves using a flag to mark the record as unavailable, rather than deleting the record from the database.
<h3>Benefits of Soft Delete</h3>
<ol>
<li>Records are easier to restore.</li>
<li>Soft delete operations are faster because we run an UPDATE command in the database. For hard delete, we will run a DELETE command which is generally slower, especially when there are related records across tables.</li>
<li>It keeps are related records in-place.</li>
<li>It is the safer option, in cases where users may need to retrieve deleted information.</li>
</ol>
<h3>Cons of Soft Delete</h3>
<ol>
<li>Added complexity of filtering out records that have been flagged as deleted.</li>
<li>Unique constraints need to be refactored to include the column representing the delete flag, so records which have been soft deleted could be recreated.</li>
<li>In some cases, records might need some unique implementations when soft deleted. For example, when soft deleting card information or payment methods, we might need to clear some sensitive fields like PAN or CVV.</li>
</ol>
Some of these fetch queries will start to look like
<pre>SELECT * FROM users WHERE is_deleted=false;</pre>
Unique constraints would also start to look this, with soft deletion in place:
<pre>CREATE UNIQUE INDEX "users_unique" ON users(is_deleted, email) WHERE is_deleted=false;</pre>
<h3>Implementing Soft Delete in Django</h3>
When implementing soft delete in Django, the first thing that’s required is a base model. This would reduce the complexity and help eliminate the aforementioned cons, as we wouldn’t need to duplicate the soft delete logic in all our models. All we would need to do, is to extend from this BaseModel.
<pre>class BaseModel(models.Model): class Meta: abstract = True # common fields go here</pre>
The first thing we want to add to our base model, is the delete flag. The is_deleted field will inform us about the availability of the record.
<pre>class BaseModel(models.Model): # ...omitted for brevity... is_deleted = models.BooleanField(default=False)</pre>
Next, we override the delete method of the model. So, we can change the default behaviour of our model’s delete from hard deletion to soft deletion.
<pre>class BaseModel(models.Model): # ...omitted for brevity... def delete(self): """Mark the record as deleted instead of deleting it""" self.is_deleted = True self.save()</pre>
With this piece of code in place, we could soft delete records as we would normally hard delete records, and maintain a Django-ic codebase.
<pre>class User(BaseModel): class Meta: unique_together = ['email', 'is_deleted'] name = models.CharField(max_length=24) email = models.EmailField() new_user = User(name="Bolaji", email="user.test@example.com") new_user.save() print(User.objects.all() # &lt;QuerySet [&lt;User: Bolaji&gt;]&gt; new_user.delete() print(new_user.is_deleted) # True print(User.objects.all()) # &lt;QuerySet []&gt;</pre>
Now that we can soft delete easily, we have to make sure that our query results never actually include any deleted record. We do so by creating a custom manager which filters out the deleted.
<pre>from django.db.models import Manager, QuerySet class AppManager(Manager): def get_queryset(self): return QuerySet(self.model, using=self._db).exclude(is_deleted=True) class BaseModel(model.Model): # ...omitted for brevity... objects = AppManager()</pre>
With this in place, we can replace the default objects field of our Model with our AppManager. This would ensure that when we query using the familiar syntax, we are getting expected
<pre>class User(BaseModel): # ...omitted for brevity... user.objects.filter(...) user.objects.all() # queries now exclude records flagged as deleted.</pre>
Wowza! Now, you can soft delete records while maintaining Django-ic code. Or, maybe there’s one more thing…
It’s possible to invoke delete on a queryset, instead of invoking it on an object. We have already catered for the latter my having a custom delete method in our BaseModel. To cater for the former scenario, we can make a custom queryset class.
<pre>from django.db.models import Manager, QuerySet class AppQuerySet(QuerySet): def delete(self): self.update(is_deleted=True) class AppManager(Manager): def get_queryset(self): return AppQuerySet(self.model, using=self._db).exclude(is_deleted=True)</pre>
Putting this altogether, we have:
<pre>from django.db.models import Manager, QuerySet class AppQuerySet(QuerySet): def delete(self): self.update(is_deleted=True) class AppManager(Manager): def get_queryset(self): return AppQuerySet(self.model, using=self._db).exclude(is_deleted=True) class BaseModel(models.Model): class Meta: abstract = True is_deleted = models.BooleanField(default=False) def delete(self): self.is_deleted = True self.save() # Sample model class Post(BaseModel): content = models.CharField(max_length=140) def __str__(self): return self.content # Create a post post = Post(content="Hello World") post.save() # Get all posts print(Post.objects.all()) # &lt;QuerySet [&lt;Post: Hello World&gt;]&gt; # Delete the post post.delete() print(Post.objects.all()) # &lt;QuerySet []&gt;</pre>
Finally, you have soft delete implemented, and you didn’t have to change your contract. Thanks for reading, buddy!
Leave a clap, share this article and do subscribe, if you found this article helpful.
<a href="https://tomisin.dev/subscribe">Subscribe * Tomisin Abiodun</a>

Learn how Django models could implement soft delete, without modifying the interfaces and contracts of models and querysets.

coding

Maximize Your Python Search Capabilities with Huntela

database

Implementing Soft Delete in Django: An Intuitive Guide

Get one coding trick and an article delivered every week at no extra cost