def stop_task(self, task_tag, stop_dependent=True, stop_requirements=False):
		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:
			stop(task)