
'''simple docstring'''







import json
from typing import TYPE_CHECKING, List, Optional, Tuple

from tokenizers import pre_tokenizers

from ...tokenization_utils_base import BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_gpta import GPTaTokenizer


if TYPE_CHECKING:
							from transformers.pipelines.conversational import Conversation


_lowercase :  Union[str, Any]    							=       logging.get_logger(__name__)

_lowercase :  Optional[Any]    							=       {"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"}

_lowercase :  str    							=       {
    "vocab_file": {
        "gpt2": "https://huggingface.co/gpt2/resolve/main/vocab.json",
        "gpt2-medium": "https://huggingface.co/gpt2-medium/resolve/main/vocab.json",
        "gpt2-large": "https://huggingface.co/gpt2-large/resolve/main/vocab.json",
        "gpt2-xl": "https://huggingface.co/gpt2-xl/resolve/main/vocab.json",
        "distilgpt2": "https://huggingface.co/distilgpt2/resolve/main/vocab.json",
    },
    "merges_file": {
        "gpt2": "https://huggingface.co/gpt2/resolve/main/merges.txt",
        "gpt2-medium": "https://huggingface.co/gpt2-medium/resolve/main/merges.txt",
        "gpt2-large": "https://huggingface.co/gpt2-large/resolve/main/merges.txt",
        "gpt2-xl": "https://huggingface.co/gpt2-xl/resolve/main/merges.txt",
        "distilgpt2": "https://huggingface.co/distilgpt2/resolve/main/merges.txt",
    },
    "tokenizer_file": {
        "gpt2": "https://huggingface.co/gpt2/resolve/main/tokenizer.json",
        "gpt2-medium": "https://huggingface.co/gpt2-medium/resolve/main/tokenizer.json",
        "gpt2-large": "https://huggingface.co/gpt2-large/resolve/main/tokenizer.json",
        "gpt2-xl": "https://huggingface.co/gpt2-xl/resolve/main/tokenizer.json",
        "distilgpt2": "https://huggingface.co/distilgpt2/resolve/main/tokenizer.json",
    },
}

_lowercase :  Dict    							=       {
    "gpt2": 1_0_2_4,
    "gpt2-medium": 1_0_2_4,
    "gpt2-large": 1_0_2_4,
    "gpt2-xl": 1_0_2_4,
    "distilgpt2": 1_0_2_4,
}






class  lowerCAmelCase__   (  lowerCamelCase_     ):
					lowerCAmelCase_        =     VOCAB_FILES_NAMES
					lowerCAmelCase_        =     PRETRAINED_VOCAB_FILES_MAP
					lowerCAmelCase_        =     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
					lowerCAmelCase_        =     ['''input_ids''', '''attention_mask''']
					lowerCAmelCase_        =     GPTaTokenizer






					def __init__(   self				,							__SCREAMING_SNAKE_CASE=None				,							__SCREAMING_SNAKE_CASE=None				,							__SCREAMING_SNAKE_CASE=None				,							__SCREAMING_SNAKE_CASE="<|endoftext|>"				,							__SCREAMING_SNAKE_CASE="<|endoftext|>"				,							__SCREAMING_SNAKE_CASE="<|endoftext|>"				,							__SCREAMING_SNAKE_CASE=False				,							**__SCREAMING_SNAKE_CASE				,							):


											"""simple docstring"""





											super().__init__(
											    __SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE				,							tokenizer_file=__SCREAMING_SNAKE_CASE				,							unk_token=__SCREAMING_SNAKE_CASE				,							bos_token=__SCREAMING_SNAKE_CASE				,							eos_token=__SCREAMING_SNAKE_CASE				,							add_prefix_space=__SCREAMING_SNAKE_CASE				,							**__SCREAMING_SNAKE_CASE				,							)

											lowercase_	:     int													=       kwargs.pop('''add_bos_token'''				,							__SCREAMING_SNAKE_CASE		)

											lowercase_	:     Union[str, Any]													=       json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()		)
											if pre_tok_state.get('''add_prefix_space'''				,							__SCREAMING_SNAKE_CASE		) != add_prefix_space:
																	lowercase_	:     Optional[Any]													=       getattr(__SCREAMING_SNAKE_CASE				,							pre_tok_state.pop('''type'''		)		)
																	lowercase_	:     List[Any]													=       add_prefix_space
																	lowercase_	:     Optional[int]													=       pre_tok_class(**__SCREAMING_SNAKE_CASE		)

											lowercase_	:     List[str]													=       add_prefix_space






					def 	_snake_case    (   self				,							*__SCREAMING_SNAKE_CASE				,							**__SCREAMING_SNAKE_CASE		):


											"""simple docstring"""





											lowercase_	:     List[str]													=       kwargs.get('''is_split_into_words'''				,							__SCREAMING_SNAKE_CASE		)
											assert self.add_prefix_space or not is_split_into_words, (
											    F'''You need to instantiate {self.__class__.__name__} with add_prefix_space=True '''
											    "to use it with pretokenized inputs."
											)

											return super()._batch_encode_plus(*__SCREAMING_SNAKE_CASE				,							**__SCREAMING_SNAKE_CASE		)






					def 	_snake_case    (   self				,							*__SCREAMING_SNAKE_CASE				,							**__SCREAMING_SNAKE_CASE		):


											"""simple docstring"""





											lowercase_	:     str													=       kwargs.get('''is_split_into_words'''				,							__SCREAMING_SNAKE_CASE		)

											assert self.add_prefix_space or not is_split_into_words, (
											    F'''You need to instantiate {self.__class__.__name__} with add_prefix_space=True '''
											    "to use it with pretokenized inputs."
											)

											return super()._encode_plus(*__SCREAMING_SNAKE_CASE				,							**__SCREAMING_SNAKE_CASE		)






					def 	_snake_case    (   self				,							__SCREAMING_SNAKE_CASE				,							__SCREAMING_SNAKE_CASE = None		):


											"""simple docstring"""





											lowercase_	:     str													=       self._tokenizer.model.save(__SCREAMING_SNAKE_CASE				,							name=__SCREAMING_SNAKE_CASE		)
											return tuple(__SCREAMING_SNAKE_CASE		)






					def 	_snake_case    (   self				,							__SCREAMING_SNAKE_CASE		):


											"""simple docstring"""





											lowercase_	:     Any													=       []
											for is_user, text in conversation.iter_texts():
																	input_ids.extend(self.encode(__SCREAMING_SNAKE_CASE				,							add_special_tokens=__SCREAMING_SNAKE_CASE		) + [self.eos_token_id]		)

											if len(__SCREAMING_SNAKE_CASE		) > self.model_max_length:
																	lowercase_	:     Union[str, Any]													=       input_ids[-self.model_max_length :]
											return input_ids





'''simple docstring'''







import argparse
import copy
def 					snake_case_		(				__SCREAMING_SNAKE_CASE					: Optional[int]							):



						"""simple docstring"""





						lowercase_	:     List[Any]													=       {}

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

						return dict_of_neighbours
def 					snake_case_		(				__SCREAMING_SNAKE_CASE					: str      ,      __SCREAMING_SNAKE_CASE					: Tuple							):



						"""simple docstring"""





						with open(__SCREAMING_SNAKE_CASE							) as f:
												lowercase_	:     List[str]													=       f.read(1							)
						lowercase_	:     Optional[int]													=       start_node

						lowercase_	:     Any													=       []

						lowercase_	:     List[str]													=       start_node

						lowercase_	:     Optional[Any]													=       0
						while visiting not in first_solution:
												lowercase_	:     Any													=       10000
												for k in dict_of_neighbours[visiting]:
																		if int(k[1]							) < int(__SCREAMING_SNAKE_CASE							) and k[0] not in first_solution:
																								lowercase_	:     List[Any]													=       k[1]
																								lowercase_	:     List[Any]													=       k[0]

												first_solution.append(__SCREAMING_SNAKE_CASE							)
												lowercase_	:     Optional[Any]													=       distance_of_first_solution + int(__SCREAMING_SNAKE_CASE							)
												lowercase_	:     int													=       best_node

						first_solution.append(__SCREAMING_SNAKE_CASE							)

						lowercase_	:     Tuple													=       0
						for k in dict_of_neighbours[first_solution[-2]]:
												if k[0] == start_node:
																		break
												position += 1

						lowercase_	:     Optional[Any]													=       (
						    distance_of_first_solution
						    + int(dict_of_neighbours[first_solution[-2]][position][1]							)
						    - 10000
						)
						return first_solution, distance_of_first_solution
def 					snake_case_		(				__SCREAMING_SNAKE_CASE					: Optional[Any]      ,      __SCREAMING_SNAKE_CASE					: Union[str, Any]							):



						"""simple docstring"""





						lowercase_	:     Tuple													=       []

						for n in solution[1:-1]:
												lowercase_	:     List[str]													=       solution.index(__SCREAMING_SNAKE_CASE							)
												for kn in solution[1:-1]:
																		lowercase_	:     Any													=       solution.index(__SCREAMING_SNAKE_CASE							)
																		if n == kn:
																								continue

																		lowercase_	:     Dict													=       copy.deepcopy(__SCREAMING_SNAKE_CASE							)
																		lowercase_	:     Dict													=       kn
																		lowercase_	:     List[Any]													=       n

																		lowercase_	:     str													=       0

																		for k in _tmp[:-1]:
																								lowercase_	:     Tuple													=       _tmp[_tmp.index(__SCREAMING_SNAKE_CASE							) + 1]
																								for i in dict_of_neighbours[k]:
																														if i[0] == next_node:
																																				lowercase_	:     Optional[Any]													=       distance + int(i[1]							)
																		_tmp.append(__SCREAMING_SNAKE_CASE							)

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

						lowercase_	:     Union[str, 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 					snake_case_		(				__SCREAMING_SNAKE_CASE					: Tuple      ,      __SCREAMING_SNAKE_CASE					: List[Any]      ,      __SCREAMING_SNAKE_CASE					: Optional[int]      ,      __SCREAMING_SNAKE_CASE					: Optional[int]      ,      __SCREAMING_SNAKE_CASE					: Optional[Any]							):



						"""simple docstring"""





						lowercase_	:     Optional[int]													=       1
						lowercase_	:     List[str]													=       first_solution
						lowercase_	:     Dict													=       []
						lowercase_	:     List[str]													=       distance_of_first_solution
						lowercase_	:     Optional[Any]													=       solution

						while count <= iters:
												lowercase_	:     int													=       find_neighborhood(__SCREAMING_SNAKE_CASE      ,      __SCREAMING_SNAKE_CASE							)
												lowercase_	:     Any													=       0
												lowercase_	:     Dict													=       neighborhood[index_of_best_solution]
												lowercase_	:     Optional[Any]													=       len(__SCREAMING_SNAKE_CASE							) - 1

												lowercase_	:     Tuple													=       False
												while not found:
																		lowercase_	:     Optional[int]													=       0
																		while i < len(__SCREAMING_SNAKE_CASE							):
																								if best_solution[i] != solution[i]:
																														lowercase_	:     Tuple													=       best_solution[i]
																														lowercase_	:     Optional[int]													=       solution[i]
																														break
																								lowercase_	:     int													=       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]							)
																								lowercase_	:     Tuple													=       True
																								lowercase_	:     Optional[int]													=       best_solution[:-1]
																								lowercase_	:     Optional[Any]													=       neighborhood[index_of_best_solution][best_cost_index]
																								if cost < best_cost:
																														lowercase_	:     Optional[Any]													=       cost
																														lowercase_	:     int													=       solution
																		else:
																								lowercase_	:     Any													=       index_of_best_solution + 1
																								lowercase_	:     Any													=       neighborhood[index_of_best_solution]

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

												lowercase_	:     List[Any]													=       count + 1

						return best_solution_ever, best_cost
def 					snake_case_		(				__SCREAMING_SNAKE_CASE					: List[str]=None							):



						"""simple docstring"""





						lowercase_	:     Any													=       generate_neighbours(args.File							)

						lowercase_						, lowercase_	:     Union[str, Any]													=       generate_first_solution(
						    args.File      ,      __SCREAMING_SNAKE_CASE							)

						lowercase_						, lowercase_	:     Optional[int]													=       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__":
							_lowercase :  Any    							=       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())



