



"""simple docstring"""

import tempfile
import unittest

import numpy as np

from diffusers import (
    DDIMScheduler,
    DPMSolverMultistepScheduler,
    EulerAncestralDiscreteScheduler,
    EulerDiscreteScheduler,
    LMSDiscreteScheduler,
    OnnxStableDiffusionPipeline,
    PNDMScheduler,
)
from diffusers.utils.testing_utils import is_onnx_available, nightly, require_onnxruntime, require_torch_gpu

from ..test_pipelines_onnx_common import OnnxPipelineTesterMixin


if is_onnx_available():
			import onnxruntime as ort







class    __lowercase     (					_UpperCAmelCase					,    unittest.TestCase):







						"""simple docstring"""







						_A		:							List[str]							       =		"""hf-internal-testing/tiny-random-OnnxStableDiffusionPipeline"""







						def 						__UpperCamelCase							(self   ,		lowercase__=0       ):
											snake_case_					:		List[str] 					=					np.random.RandomState(lowercase__       )
											snake_case_					:		List[str] 					=					{
											    """prompt""": """A painting of a squirrel eating a burger""",
											    """generator""": generator,
											    """num_inference_steps""": 2,
											    """guidance_scale""": 7.5,
											    """output_type""": """numpy""",
											}
											return inputs







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Dict 					=					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,		provider="""CPUExecutionProvider"""       )
											pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		Optional[Any] 					=					self.get_dummy_inputs()
											snake_case_					:		Dict 					=					pipe(**lowercase__       ).images
											snake_case_					:		Tuple 					=					image[0, -3:, -3:, -1]

											assert image.shape == (1, 1_28, 1_28, 3)
											snake_case_					:		Union[str, Any] 					=					np.array([0.65072, 0.58492, 0.48219, 0.55521, 0.53180, 0.55939, 0.50697, 0.39800, 0.46455]       )

											assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		str 					=					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,		provider="""CPUExecutionProvider"""       )
											snake_case_					:		Union[str, Any] 					=					PNDMScheduler.from_config(pipe.scheduler.config   ,		skip_prk_steps=lowercase__       )
											pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		Optional[Any] 					=					self.get_dummy_inputs()
											snake_case_					:		str 					=					pipe(**lowercase__       ).images
											snake_case_					:		Optional[int] 					=					image[0, -3:, -3:, -1]

											assert image.shape == (1, 1_28, 1_28, 3)
											snake_case_					:		Tuple 					=					np.array([0.65863, 0.59425, 0.49326, 0.56313, 0.53875, 0.56627, 0.51065, 0.39777, 0.46330]       )

											assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		str 					=					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,		provider="""CPUExecutionProvider"""       )
											snake_case_					:		Any 					=					LMSDiscreteScheduler.from_config(pipe.scheduler.config       )
											pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		int 					=					self.get_dummy_inputs()
											snake_case_					:		Any 					=					pipe(**lowercase__       ).images
											snake_case_					:		List[str] 					=					image[0, -3:, -3:, -1]

											assert image.shape == (1, 1_28, 1_28, 3)
											snake_case_					:		Dict 					=					np.array([0.53755, 0.60786, 0.47402, 0.49488, 0.51869, 0.49819, 0.47985, 0.38957, 0.44279]       )

											assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		List[Any] 					=					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,		provider="""CPUExecutionProvider"""       )
											snake_case_					:		Optional[int] 					=					EulerDiscreteScheduler.from_config(pipe.scheduler.config       )
											pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		Optional[Any] 					=					self.get_dummy_inputs()
											snake_case_					:		Optional[Any] 					=					pipe(**lowercase__       ).images
											snake_case_					:		Dict 					=					image[0, -3:, -3:, -1]

											assert image.shape == (1, 1_28, 1_28, 3)
											snake_case_					:		Tuple 					=					np.array([0.53755, 0.60786, 0.47402, 0.49488, 0.51869, 0.49819, 0.47985, 0.38957, 0.44279]       )

											assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		int 					=					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,		provider="""CPUExecutionProvider"""       )
											snake_case_					:		Optional[int] 					=					EulerAncestralDiscreteScheduler.from_config(pipe.scheduler.config       )
											pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		Union[str, Any] 					=					self.get_dummy_inputs()
											snake_case_					:		Optional[Any] 					=					pipe(**lowercase__       ).images
											snake_case_					:		Dict 					=					image[0, -3:, -3:, -1]

											assert image.shape == (1, 1_28, 1_28, 3)
											snake_case_					:		str 					=					np.array([0.53817, 0.60812, 0.47384, 0.49530, 0.51894, 0.49814, 0.47984, 0.38958, 0.44271]       )

											assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Any 					=					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,		provider="""CPUExecutionProvider"""       )
											snake_case_					:		Union[str, Any] 					=					DPMSolverMultistepScheduler.from_config(pipe.scheduler.config       )
											pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		int 					=					self.get_dummy_inputs()
											snake_case_					:		Optional[int] 					=					pipe(**lowercase__       ).images
											snake_case_					:		List[Any] 					=					image[0, -3:, -3:, -1]

											assert image.shape == (1, 1_28, 1_28, 3)
											snake_case_					:		Tuple 					=					np.array([0.53895, 0.60808, 0.47933, 0.49608, 0.51886, 0.49950, 0.48053, 0.38957, 0.44200]       )

											assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Dict 					=					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,		provider="""CPUExecutionProvider"""       )
											pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		Tuple 					=					self.get_dummy_inputs()
											snake_case_					:		List[Any] 					=					3 * [inputs["""prompt"""]]

											# forward
											snake_case_					:		Optional[Any] 					=					pipe(**lowercase__       )
											snake_case_					:		Optional[Any] 					=					output.images[0, -3:, -3:, -1]

											snake_case_					:		Optional[int] 					=					self.get_dummy_inputs()
											snake_case_					:		Optional[int] 					=					3 * [inputs.pop("""prompt"""       )]

											snake_case_					:		str 					=					pipe.tokenizer(
											    lowercase__   ,		padding="""max_length"""   ,		max_length=pipe.tokenizer.model_max_length   ,		truncation=lowercase__   ,		return_tensors="""np"""   ,		)
											snake_case_					:		Any 					=					text_inputs["""input_ids"""]

											snake_case_					:		Dict 					=					pipe.text_encoder(input_ids=text_inputs.astype(np.intaa       )       )[0]

											snake_case_					:		Optional[int] 					=					prompt_embeds

											# forward
											snake_case_					:		Optional[int] 					=					pipe(**lowercase__       )
											snake_case_					:		int 					=					output.images[0, -3:, -3:, -1]

											assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()       ).max() < 1e-4







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		str 					=					OnnxStableDiffusionPipeline.from_pretrained(self.hub_checkpoint   ,		provider="""CPUExecutionProvider"""       )
											pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		Tuple 					=					self.get_dummy_inputs()
											snake_case_					:		List[Any] 					=					3 * ["""this is a negative prompt"""]
											snake_case_					:		Any 					=					negative_prompt
											snake_case_					:		Dict 					=					3 * [inputs["""prompt"""]]

											# forward
											snake_case_					:		Optional[int] 					=					pipe(**lowercase__       )
											snake_case_					:		List[Any] 					=					output.images[0, -3:, -3:, -1]

											snake_case_					:		Optional[int] 					=					self.get_dummy_inputs()
											snake_case_					:		List[Any] 					=					3 * [inputs.pop("""prompt"""       )]

											snake_case_					:		List[Any] 					=					[]
											for p in [prompt, negative_prompt]:
																snake_case_					:		str 					=					pipe.tokenizer(
																    lowercase__   ,		padding="""max_length"""   ,		max_length=pipe.tokenizer.model_max_length   ,		truncation=lowercase__   ,		return_tensors="""np"""   ,		)
																snake_case_					:		Any 					=					text_inputs["""input_ids"""]

																embeds.append(pipe.text_encoder(input_ids=text_inputs.astype(np.intaa       )       )[0]       )

											snake_case_					,			snake_case_					:		str 					=					embeds

											# forward
											snake_case_					:		str 					=					pipe(**lowercase__       )
											snake_case_					:		int 					=					output.images[0, -3:, -3:, -1]

											assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()       ).max() < 1e-4







@nightly
@require_onnxruntime
@require_torch_gpu
class    __lowercase     (					unittest.TestCase):







						"""simple docstring"""







						@property
						def 						__UpperCamelCase							(self       ):
											return (
											    "CUDAExecutionProvider",
											    {
											        "gpu_mem_limit": "15000000000",  # 15GB
											        "arena_extend_strategy": "kSameAsRequested",
											    },
											)







						@property
						def 						__UpperCamelCase							(self       ):
											snake_case_					:		str 					=					ort.SessionOptions()
											snake_case_					:		Any 					=					False
											return options







						def 						__UpperCamelCase							(self       ):
											# using the PNDM scheduler by default
											snake_case_					:		List[Any] 					=					OnnxStableDiffusionPipeline.from_pretrained(
											    """CompVis/stable-diffusion-v1-4"""   ,		revision="""onnx"""   ,		safety_checker=lowercase__   ,		feature_extractor=lowercase__   ,		provider=self.gpu_provider   ,		sess_options=self.gpu_options   ,		)
											sd_pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		Any 					=					"""A painting of a squirrel eating a burger"""
											np.random.seed(0       )
											snake_case_					:		Dict 					=					sd_pipe([prompt]   ,		guidance_scale=6.0   ,		num_inference_steps=10   ,		output_type="""np"""       )
											snake_case_					:		List[Any] 					=					output.images

											snake_case_					:		Optional[Any] 					=					image[0, -3:, -3:, -1]

											assert image.shape == (1, 5_12, 5_12, 3)
											snake_case_					:		Dict 					=					np.array([0.0452, 0.0390, 0.0087, 0.0350, 0.0617, 0.0364, 0.0544, 0.0523, 0.0720]       )

											assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-3







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		str 					=					DDIMScheduler.from_pretrained(
											    """runwayml/stable-diffusion-v1-5"""   ,		subfolder="""scheduler"""   ,		revision="""onnx"""       )
											snake_case_					:		List[str] 					=					OnnxStableDiffusionPipeline.from_pretrained(
											    """runwayml/stable-diffusion-v1-5"""   ,		revision="""onnx"""   ,		scheduler=lowercase__   ,		safety_checker=lowercase__   ,		feature_extractor=lowercase__   ,		provider=self.gpu_provider   ,		sess_options=self.gpu_options   ,		)
											sd_pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		List[Any] 					=					"""open neural network exchange"""
											snake_case_					:		str 					=					np.random.RandomState(0       )
											snake_case_					:		Dict 					=					sd_pipe([prompt]   ,		guidance_scale=7.5   ,		num_inference_steps=10   ,		generator=lowercase__   ,		output_type="""np"""       )
											snake_case_					:		int 					=					output.images
											snake_case_					:		Optional[Any] 					=					image[0, -3:, -3:, -1]

											assert image.shape == (1, 5_12, 5_12, 3)
											snake_case_					:		str 					=					np.array([0.2867, 0.1974, 0.1481, 0.7294, 0.7251, 0.6667, 0.4194, 0.5642, 0.6486]       )

											assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-3







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Optional[Any] 					=					LMSDiscreteScheduler.from_pretrained(
											    """runwayml/stable-diffusion-v1-5"""   ,		subfolder="""scheduler"""   ,		revision="""onnx"""       )
											snake_case_					:		List[Any] 					=					OnnxStableDiffusionPipeline.from_pretrained(
											    """runwayml/stable-diffusion-v1-5"""   ,		revision="""onnx"""   ,		scheduler=lowercase__   ,		safety_checker=lowercase__   ,		feature_extractor=lowercase__   ,		provider=self.gpu_provider   ,		sess_options=self.gpu_options   ,		)
											sd_pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		Dict 					=					"""open neural network exchange"""
											snake_case_					:		Any 					=					np.random.RandomState(0       )
											snake_case_					:		str 					=					sd_pipe([prompt]   ,		guidance_scale=7.5   ,		num_inference_steps=10   ,		generator=lowercase__   ,		output_type="""np"""       )
											snake_case_					:		Union[str, Any] 					=					output.images
											snake_case_					:		str 					=					image[0, -3:, -3:, -1]

											assert image.shape == (1, 5_12, 5_12, 3)
											snake_case_					:		Optional[int] 					=					np.array([0.2306, 0.1959, 0.1593, 0.6549, 0.6394, 0.5408, 0.5065, 0.6010, 0.6161]       )

											assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-3







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		str 					=					0

											def test_callback_fn(lowercase__   ,		lowercase__   ,		lowercase__       ) -> None:
																snake_case_					:		Optional[int] 					=					True
																nonlocal number_of_steps
																number_of_steps += 1
																if step == 0:
																					assert latents.shape == (1, 4, 64, 64)
																					snake_case_					:		str 					=					latents[0, -3:, -3:, -1]
																					snake_case_					:		str 					=					np.array(
																					    [-0.6772, -0.3835, -1.2456, 0.1905, -1.0974, 0.6967, -1.9353, 0.0178, 1.0167]       )

																					assert np.abs(latents_slice.flatten() - expected_slice       ).max() < 1e-3
																elif step == 5:
																					assert latents.shape == (1, 4, 64, 64)
																					snake_case_					:		Union[str, Any] 					=					latents[0, -3:, -3:, -1]
																					snake_case_					:		Optional[Any] 					=					np.array(
																					    [-0.3351, 0.2241, -0.1837, -0.2325, -0.6577, 0.3393, -0.0241, 0.5899, 1.3875]       )

																					assert np.abs(latents_slice.flatten() - expected_slice       ).max() < 1e-3

											snake_case_					:		Union[str, Any] 					=					False

											snake_case_					:		Any 					=					OnnxStableDiffusionPipeline.from_pretrained(
											    """runwayml/stable-diffusion-v1-5"""   ,		revision="""onnx"""   ,		safety_checker=lowercase__   ,		feature_extractor=lowercase__   ,		provider=self.gpu_provider   ,		sess_options=self.gpu_options   ,		)
											pipe.set_progress_bar_config(disable=lowercase__       )

											snake_case_					:		Optional[int] 					=					"""Andromeda galaxy in a bottle"""

											snake_case_					:		Union[str, Any] 					=					np.random.RandomState(0       )
											pipe(
											    prompt=lowercase__   ,		num_inference_steps=5   ,		guidance_scale=7.5   ,		generator=lowercase__   ,		callback=lowercase__   ,		callback_steps=1   ,		)
											assert test_callback_fn.has_been_called
											assert number_of_steps == 6







						def 						__UpperCamelCase							(self       ):
											snake_case_					:		Optional[int] 					=					OnnxStableDiffusionPipeline.from_pretrained(
											    """runwayml/stable-diffusion-v1-5"""   ,		revision="""onnx"""   ,		safety_checker=lowercase__   ,		feature_extractor=lowercase__   ,		provider=self.gpu_provider   ,		sess_options=self.gpu_options   ,		)
											assert isinstance(lowercase__   ,		lowercase__       )
											assert pipe.safety_checker is None

											snake_case_					:		int 					=					pipe("""example prompt"""   ,		num_inference_steps=2       ).images[0]
											assert image is not None

											# check that there's no error when saving a pipeline with one of the models being None
											with tempfile.TemporaryDirectory() as tmpdirname:
																pipe.save_pretrained(lowercase__       )
																snake_case_					:		int 					=					OnnxStableDiffusionPipeline.from_pretrained(lowercase__       )

											# sanity check that the pipeline still works
											assert pipe.safety_checker is None
											snake_case_					:		Optional[Any] 					=					pipe("""example prompt"""   ,		num_inference_steps=2       ).images[0]
											assert image is not None









"""simple docstring"""

import argparse
import copy







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  Any			):



					"""simple docstring"""





					snake_case_					:		List[Any] 					=					{}

					with open(SCREAMING_SNAKE_CASE__			) as f:
										for line in f:
															if line.split()[0] not in dict_of_neighbours:
																				snake_case_					:		int 					=					[]
																				_list.append([line.split()[1], line.split()[2]]			)
																				snake_case_					:		Optional[Any] 					=					_list
															else:
																				dict_of_neighbours[line.split()[0]].append(
																				    [line.split()[1], line.split()[2]]			)
															if line.split()[1] not in dict_of_neighbours:
																				snake_case_					:		str 					=					[]
																				_list.append([line.split()[0], line.split()[2]]			)
																				snake_case_					:		Optional[Any] 					=					_list
															else:
																				dict_of_neighbours[line.split()[1]].append(
																				    [line.split()[0], line.split()[2]]			)

					return dict_of_neighbours







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  List[Any]				,    SCREAMING_SNAKE_CASE__ :  str			):



					"""simple docstring"""





					with open(SCREAMING_SNAKE_CASE__			) as f:
										snake_case_					:		Optional[Any] 					=					f.read(1			)
					snake_case_					:		Union[str, Any] 					=					start_node

					snake_case_					:		Dict 					=					[]

					snake_case_					:		Union[str, Any] 					=					start_node

					snake_case_					:		Tuple 					=					0
					while visiting not in first_solution:
										snake_case_					:		int 					=					1_0_0_0_0
										for k in dict_of_neighbours[visiting]:
															if int(k[1]			) < int(SCREAMING_SNAKE_CASE__			) and k[0] not in first_solution:
																				snake_case_					:		Union[str, Any] 					=					k[1]
																				snake_case_					:		Any 					=					k[0]

										first_solution.append(SCREAMING_SNAKE_CASE__			)
										snake_case_					:		Tuple 					=					distance_of_first_solution + int(SCREAMING_SNAKE_CASE__			)
										snake_case_					:		List[str] 					=					best_node

					first_solution.append(SCREAMING_SNAKE_CASE__			)

					snake_case_					:		Optional[Any] 					=					0
					for k in dict_of_neighbours[first_solution[-2]]:
										if k[0] == start_node:
															break
										position += 1

					snake_case_					:		int 					=					(
					    distance_of_first_solution
					    + int(dict_of_neighbours[first_solution[-2]][position][1]			)
					    - 1_0_0_0_0
					)
					return first_solution, distance_of_first_solution







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  Union[str, Any]				,    SCREAMING_SNAKE_CASE__ :  Optional[int]			):



					"""simple docstring"""





					snake_case_					:		Union[str, Any] 					=					[]

					for n in solution[1:-1]:
										snake_case_					:		str 					=					solution.index(SCREAMING_SNAKE_CASE__			)
										for kn in solution[1:-1]:
															snake_case_					:		Tuple 					=					solution.index(SCREAMING_SNAKE_CASE__			)
															if n == kn:
																				continue

															snake_case_					:		Optional[Any] 					=					copy.deepcopy(SCREAMING_SNAKE_CASE__			)
															snake_case_					:		int 					=					kn
															snake_case_					:		Dict 					=					n

															snake_case_					:		Optional[int] 					=					0

															for k in _tmp[:-1]:
																				snake_case_					:		Dict 					=					_tmp[_tmp.index(SCREAMING_SNAKE_CASE__			) + 1]
																				for i in dict_of_neighbours[k]:
																									if i[0] == next_node:
																														snake_case_					:		Dict 					=					distance + int(i[1]			)
															_tmp.append(SCREAMING_SNAKE_CASE__			)

															if _tmp not in neighborhood_of_solution:
																				neighborhood_of_solution.append(_tmp			)

					snake_case_					:		Optional[Any] 					=					len(neighborhood_of_solution[0]			) - 1

					neighborhood_of_solution.sort(key=lambda SCREAMING_SNAKE_CASE__			: x[index_of_last_item_in_the_list]			)
					return neighborhood_of_solution







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  List[str]				,    SCREAMING_SNAKE_CASE__ :  Dict				,    SCREAMING_SNAKE_CASE__ :  List[Any]				,    SCREAMING_SNAKE_CASE__ :  str				,    SCREAMING_SNAKE_CASE__ :  List[Any]			):



					"""simple docstring"""





					snake_case_					:		Dict 					=					1
					snake_case_					:		List[Any] 					=					first_solution
					snake_case_					:		List[Any] 					=					[]
					snake_case_					:		Optional[Any] 					=					distance_of_first_solution
					snake_case_					:		Dict 					=					solution

					while count <= iters:
										snake_case_					:		List[str] 					=					find_neighborhood(SCREAMING_SNAKE_CASE__				,    SCREAMING_SNAKE_CASE__			)
										snake_case_					:		List[Any] 					=					0
										snake_case_					:		List[Any] 					=					neighborhood[index_of_best_solution]
										snake_case_					:		Union[str, Any] 					=					len(SCREAMING_SNAKE_CASE__			) - 1

										snake_case_					:		List[str] 					=					False
										while not found:
															snake_case_					:		Tuple 					=					0
															while i < len(SCREAMING_SNAKE_CASE__			):
																				if best_solution[i] != solution[i]:
																									snake_case_					:		Optional[Any] 					=					best_solution[i]
																									snake_case_					:		int 					=					solution[i]
																									break
																				snake_case_					:		List[str] 					=					i + 1

															if [first_exchange_node, second_exchange_node] not in tabu_list and [
															    second_exchange_node,
															    first_exchange_node,
															] not in tabu_list:
																				tabu_list.append([first_exchange_node, second_exchange_node]			)
																				snake_case_					:		Tuple 					=					True
																				snake_case_					:		Dict 					=					best_solution[:-1]
																				snake_case_					:		Tuple 					=					neighborhood[index_of_best_solution][best_cost_index]
																				if cost < best_cost:
																									snake_case_					:		Tuple 					=					cost
																									snake_case_					:		Union[str, Any] 					=					solution
															else:
																				snake_case_					:		str 					=					index_of_best_solution + 1
																				snake_case_					:		Tuple 					=					neighborhood[index_of_best_solution]

										if len(SCREAMING_SNAKE_CASE__			) >= size:
															tabu_list.pop(0			)

										snake_case_					:		List[str] 					=					count + 1

					return best_solution_ever, best_cost







def 							SCREAMING_SNAKE_CASE__      (		SCREAMING_SNAKE_CASE__ :  Optional[Any]=None			):



					"""simple docstring"""





					snake_case_					:		Tuple 					=					generate_neighbours(args.File			)

					snake_case_					,			snake_case_					:		Optional[Any] 					=					generate_first_solution(
					    args.File				,    SCREAMING_SNAKE_CASE__			)

					snake_case_					,			snake_case_					:		Dict 					=					tabu_search(
					    SCREAMING_SNAKE_CASE__				,    SCREAMING_SNAKE_CASE__				,    SCREAMING_SNAKE_CASE__				,    args.Iterations				,    args.Size				,    )

					print(f'Best solution: {best_sol}, with total distance: {best_cost}.'			)


if __name__ == "__main__":
			a_			   =					argparse.ArgumentParser(description='''Tabu Search''')
			parser.add_argument(
			    '''-f''',
			    '''--File''',
			    type=str,
			    help='''Path to the file containing the data''',
			    required=True,
			)
			parser.add_argument(
			    '''-i''',
			    '''--Iterations''',
			    type=int,
			    help='''How many iterations the algorithm should perform''',
			    required=True,
			)
			parser.add_argument(
			    '''-s''', '''--Size''', type=int, help='''Size of the tabu list''', required=True
			)

			# Pass the arguments to main method
			main(parser.parse_args())




