django-taggit common tags only visible from base url

In get_common_tags you don't need the request headers or anything. So you can extract this function from Home class and you might consume/call from multiple views.

def get_common_tags(self):
    #consider using try/catch        
    try:
        return Group.tags.most_common()[:2]
    except:
        return {'no tag'}

class Home(ListView):
   model = Group
   template_name = 'home.html'
   ordering = ['-posted']

   def get_context_data(self, **kwargs):
       kwargs['common_tags'] = get_common_tags()
       return super().get_context_data(**kwargs)

class TagFilter(ListView):
   model = Group
   template_name = 'home.html'
   context_object_name = 'group'
   
   def get_queryset(self):
          # all tags
       tag_list = Group.objects.filter(tags__slug=self.kwargs.get('tag_slug'))
       return tag_list

   def get_context_data(self, *args, **kwargs):
       tag_list = Group.objects.filter(tags__slug=self.kwargs.get('tag_slug'))
       tag_list_is_empty = True
       if tag_list.exists():
           tag_list_is_empty = False
       context = super(TagFilter, self).get_context_data()
       context["tag_list_is_empty"] = tag_list_is_empty
       # add common tags to context
       context["common_tags"] = get_common_tags()
       return context

First of all, as mentioned by Egemen SOYLU in the answers, take the common tags function out of the Home view so you can use it in any other. The "context" is specific to each view and are not inherited when following links to another view. If you switch pages and there is a new view for it, a new request is sent from the client side and the server renders the corresponding page, context included.

With the above said, you have a few options.

Make a function to retrieve common tags:

def get_common_tags():  # this function needs no input, just trigger
    try:
        tags = Group.tags.most_common()[:2]
        return tags
    except:
        return []  # Return an empty list if not found.

To get the common tags context information from a view, insert the function and assign it a named list (a.k.a. "key-value pair") in the context dictionary:

def get_context_data(self, **kwargs):
    context = super().get_context_data(**kwargs) #retrieve default view context info, i.e.: model query.
    """add your other context info here..."""
    context['common_tags'] = get_common_tags() #retrieve the common tags from the function
    """context['key_name'] = values..."""
    return context

The above should work for any view where you want to include the common tags and you should refer to it as 'common_tags' in the template.

For the filtered view, you can simplify the logic a bit by grouping functions:

class TagFilter(ListView):
    model = Group
    template_name = 'home.html'
    context_object_name = 'group' """<--- you can get rid of this line 
    as you can build your context information at will. Keep reading..."""

""" def get_queryset(self): <--- you don't need this function, send 
    everything together in the context dictionary.
    Just add the queryset to the get_context_data() function below...
        tag_list = Group.objects.filter(tags__slug=self.kwargs.get('tag_slug'))
        return tag_list"""  

def get_context_data(self, *args, **kwargs):
    context = super().get_context_data(**kwargs) """Whatever you need from the
    request kwargs..."""
    tag_list = [] """First define an empty list in case getting 
    the Group model information returns an empty list."""

    try:
        tag_list = Group.objects.filter(tags__slug=self.kwargs.get('tag_slug'))
    else:
        pass """do not modify the empty tag_list"""
    group = Group.objects.all() """ignore this line if you're using the
    context_object_name variable or add any filter by using the kwargs.get
    method. In this last scenario, don't forget to add context['group']=group"""

    context["tag_list"] = tag_list """empty if the Group filter returns empty"""

    context["common_tags"] = get_common_tags() """ this will return an empty
    queryset if there are no common tags found, as defined by the function 
    above"""

    return context

So, how do you use empty values from context dictionaries? Go to your HTML templates and follow this logic:

• For an empty queryset, use "if" or "if not" Django template tags.
• If the key name returns content, do your algo in the template.

So, in the template:

{% if tag_list %} <!-- if there is content in "tag_list" key name, do... -->
    {%  for tag in tag_list %}
        ...
    {% endfor %}
{% else %} <!-- if the list is empty, do something (i.e.: display a message) -->
{% endif %}

Same applies for any list in the context dict. If you have doubts with the template tags, {% if not key_from_context_dict %} works the same as {% if key_from_context_dict == Null %}}

Hope this works. :)