docs: def stop_task(self, task_tag, stop_dependent=True, stop_requirements=False):
  		""" Stop task with the given task tag. If task already stopped, then nothing happens.
  
  		:param task_tag: task to stop
  		:param stop_dependent: if True, then every task, that require the given task as dependency, will be \
  		stopped before.
  		:param stop_requirements: if True, then every task, that is required as dependency for the given task, \
  		will be stopped after.
  		:return: None
  		"""
  		# TODO: "coverage" requires more tests
  
  		task = self.started_tasks(task_registry_id=task_tag)
  
  		if task is None:
  			return
  
  		def stop(task_to_stop):
  			if task_to_stop in self.__started:
  				if isinstance(task_to_stop, WStoppableTask) is True:
  					task_to_stop.stop()
  				self.__started.remove(task_to_stop)
  
  		def stop_dependency(task_to_stop):
  			deeper_dependencies = []
  			for dependent_task in self.__started:
  				if task_to_stop.__registry_tag__ in dependent_task.__class__.__dependency__:
  					deeper_dependencies.append(dependent_task)
  
  			for dependent_task in deeper_dependencies:
  				stop_dependency(dependent_task)
  
  			stop(task_to_stop)
  
  		def calculate_requirements(task_to_stop, cross_requirements=False):
  			requirements = set()
  
  			for dependent_task in self.__started:
  				if dependent_task.__class__.__registry_tag__ in task_to_stop.__class__.__dependency__:
  					requirements.add(dependent_task)
  
  			if cross_requirements is True:
  				return requirements
  
  			result = set()
  			for task_a in requirements:
  				requirement_match = False
  				for task_b in requirements:
  					if task_a.__class__.__registry_tag__ in task_b.__class__.__dependency__:
  						requirement_match = True
  						break
  				if requirement_match is False:
  					result.add(task_a)
  			return result
  
  		def calculate_priorities(task_to_stop, *extra_tasks, current_result=None, requirements_left=None):
  			if current_result is None:
  				current_result = []
  
  			tasks_to_stop = [task_to_stop]
  			if len(extra_tasks) > 0:
  				tasks_to_stop.extend(extra_tasks)
  
  			current_result.append(list(tasks_to_stop))
  
  			all_requirements = calculate_requirements(tasks_to_stop[0], cross_requirements=True)
  			nested_requirements = calculate_requirements(tasks_to_stop[0])
  
  			for dependent_task in tasks_to_stop[1:]:
  				nested_requirements = nested_requirements.union(calculate_requirements(dependent_task))
  				all_requirements.update(calculate_requirements(dependent_task, cross_requirements=True))
  
  			all_requirements = all_requirements.difference(nested_requirements)
  
  			if requirements_left is not None:
  				requirements_left = requirements_left.difference(all_requirements)
  				nested_requirements.update(requirements_left)
  
  			if len(nested_requirements) == 0:
  				return current_result
  
  			return calculate_priorities(
  				*list(nested_requirements), current_result=current_result, requirements_left=all_requirements
  			)
  
  		if stop_dependent is True:
  			stop_dependency(task)
  
  		if stop_requirements is True:
  			for task_list in calculate_priorities(task):
  				for single_task in task_list:
  					stop(single_task)
  
  		if stop_dependent is not True:  # check if we've already stopped this task
  			stop(task)