

import os
import unittest

from transformers import ElectraTokenizerFast
from transformers.models.electra.tokenization_electra import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    ElectraTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english

@require_tokenizers
class  a     (		UpperCAmelCase							,       unittest.TestCase ):
						_lowercase			  =	ElectraTokenizer
						_lowercase			  =	ElectraTokenizerFast
						_lowercase			  =	True
						_lowercase			  =	True
						_lowercase			  =	filter_non_english


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										super().setUp()

										_UpperCAmelCase				:						Any       						=			[
										    "[UNK]",
										    "[CLS]",
										    "[SEP]",
										    "[PAD]",
										    "[MASK]",
										    "want",
										    "##want",
										    "##ed",
										    "wa",
										    "un",
										    "runn",
										    "##ing",
										    ",",
										    "low",
										    "lowest",
										]
										_UpperCAmelCase				:						int       						=			os.path.join(self.tmpdirname  ,    VOCAB_FILES_NAMES["vocab_file"]		)
										with open(self.vocab_file  ,    "w"  ,    encoding="utf-8"		) as vocab_writer:
														vocab_writer.write("".join([x + "\n" for x in vocab_tokens]		)		)


						def 				_UpperCAmelCase (				self  ,    A_		):







										'''simple docstring'''


										_UpperCAmelCase				:						Tuple       						=			"UNwant\u00E9d,running"
										_UpperCAmelCase				:						Any       						=			"unwanted, running"
										return input_text, output_text


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Tuple       						=			self.tokenizer_class(self.vocab_file		)

										_UpperCAmelCase				:						Any       						=			tokenizer.tokenize("UNwant\u00E9d,running"		)
										self.assertListEqual(A_  ,    ["un", "##want", "##ed", ",", "runn", "##ing"]		)
										self.assertListEqual(tokenizer.convert_tokens_to_ids(A_		)  ,    [9, 6, 7, 12, 10, 11]		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										if not self.test_rust_tokenizer:
														return

										_UpperCAmelCase				:						List[Any]       						=			self.get_tokenizer()
										_UpperCAmelCase				:						Dict       						=			self.get_rust_tokenizer()

										_UpperCAmelCase				:						Optional[Any]       						=			"UNwant\u00E9d,running"

										_UpperCAmelCase				:						Optional[int]       						=			tokenizer.tokenize(A_		)
										_UpperCAmelCase				:						Tuple       						=			rust_tokenizer.tokenize(A_		)
										self.assertListEqual(A_  ,    A_		)

										_UpperCAmelCase				:						int       						=			tokenizer.encode(A_  ,    add_special_tokens=A_		)
										_UpperCAmelCase				:						Union[str, Any]       						=			rust_tokenizer.encode(A_  ,    add_special_tokens=A_		)
										self.assertListEqual(A_  ,    A_		)

										_UpperCAmelCase				:						Any       						=			self.get_rust_tokenizer()
										_UpperCAmelCase				:						Union[str, Any]       						=			tokenizer.encode(A_		)
										_UpperCAmelCase				:						List[Any]       						=			rust_tokenizer.encode(A_		)
										self.assertListEqual(A_  ,    A_		)

										# With lower casing
										_UpperCAmelCase				:						Dict       						=			self.get_tokenizer(do_lower_case=A_		)
										_UpperCAmelCase				:						List[str]       						=			self.get_rust_tokenizer(do_lower_case=A_		)

										_UpperCAmelCase				:						int       						=			"UNwant\u00E9d,running"

										_UpperCAmelCase				:						int       						=			tokenizer.tokenize(A_		)
										_UpperCAmelCase				:						List[str]       						=			rust_tokenizer.tokenize(A_		)
										self.assertListEqual(A_  ,    A_		)

										_UpperCAmelCase				:						Tuple       						=			tokenizer.encode(A_  ,    add_special_tokens=A_		)
										_UpperCAmelCase				:						Optional[int]       						=			rust_tokenizer.encode(A_  ,    add_special_tokens=A_		)
										self.assertListEqual(A_  ,    A_		)

										_UpperCAmelCase				:						Union[str, Any]       						=			self.get_rust_tokenizer()
										_UpperCAmelCase				:						Any       						=			tokenizer.encode(A_		)
										_UpperCAmelCase				:						List[Any]       						=			rust_tokenizer.encode(A_		)
										self.assertListEqual(A_  ,    A_		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Union[str, Any]       						=			BasicTokenizer()

										self.assertListEqual(tokenizer.tokenize("ah\u535A\u63A8zz"		)  ,    ["ah", "\u535A", "\u63A8", "zz"]		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Any       						=			BasicTokenizer(do_lower_case=A_		)

										self.assertListEqual(
										    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "		)  ,    ["hello", "!", "how", "are", "you", "?"]		)
										self.assertListEqual(tokenizer.tokenize("H\u00E9llo"		)  ,    ["hello"]		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						str       						=			BasicTokenizer(do_lower_case=A_  ,    strip_accents=A_		)

										self.assertListEqual(
										    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "		)  ,    ["hällo", "!", "how", "are", "you", "?"]		)
										self.assertListEqual(tokenizer.tokenize("H\u00E9llo"		)  ,    ["h\u00E9llo"]		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						List[Any]       						=			BasicTokenizer(do_lower_case=A_  ,    strip_accents=A_		)

										self.assertListEqual(
										    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "		)  ,    ["hallo", "!", "how", "are", "you", "?"]		)
										self.assertListEqual(tokenizer.tokenize("H\u00E9llo"		)  ,    ["hello"]		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Optional[int]       						=			BasicTokenizer(do_lower_case=A_		)

										self.assertListEqual(
										    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "		)  ,    ["hallo", "!", "how", "are", "you", "?"]		)
										self.assertListEqual(tokenizer.tokenize("H\u00E9llo"		)  ,    ["hello"]		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Any       						=			BasicTokenizer(do_lower_case=A_		)

										self.assertListEqual(
										    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU?  "		)  ,    ["HeLLo", "!", "how", "Are", "yoU", "?"]		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						int       						=			BasicTokenizer(do_lower_case=A_  ,    strip_accents=A_		)

										self.assertListEqual(
										    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "		)  ,    ["HäLLo", "!", "how", "Are", "yoU", "?"]		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Any       						=			BasicTokenizer(do_lower_case=A_  ,    strip_accents=A_		)

										self.assertListEqual(
										    tokenizer.tokenize(" \tHäLLo!how  \n Are yoU?  "		)  ,    ["HaLLo", "!", "how", "Are", "yoU", "?"]		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Optional[Any]       						=			BasicTokenizer(do_lower_case=A_  ,    never_split=["[UNK]"]		)

										self.assertListEqual(
										    tokenizer.tokenize(" \tHeLLo!how  \n Are yoU? [UNK]"		)  ,    ["HeLLo", "!", "how", "Are", "yoU", "?", "[UNK]"]		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Any       						=			["[UNK]", "[CLS]", "[SEP]", "want", "##want", "##ed", "wa", "un", "runn", "##ing"]

										_UpperCAmelCase				:						Optional[Any]       						=			{}
										for i, token in enumerate(A_		):
														_UpperCAmelCase				:						Dict       						=			i
										_UpperCAmelCase				:						Optional[Any]       						=			WordpieceTokenizer(vocab=A_  ,    unk_token="[UNK]"		)

										self.assertListEqual(tokenizer.tokenize(""		)  ,    []		)

										self.assertListEqual(tokenizer.tokenize("unwanted running"		)  ,    ["un", "##want", "##ed", "runn", "##ing"]		)

										self.assertListEqual(tokenizer.tokenize("unwantedX running"		)  ,    ["[UNK]", "runn", "##ing"]		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										self.assertTrue(_is_whitespace(" "		)		)
										self.assertTrue(_is_whitespace("\t"		)		)
										self.assertTrue(_is_whitespace("\r"		)		)
										self.assertTrue(_is_whitespace("\n"		)		)
										self.assertTrue(_is_whitespace("\u00A0"		)		)

										self.assertFalse(_is_whitespace("A"		)		)
										self.assertFalse(_is_whitespace("-"		)		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										self.assertTrue(_is_control("\u0005"		)		)

										self.assertFalse(_is_control("A"		)		)
										self.assertFalse(_is_control(" "		)		)
										self.assertFalse(_is_control("\t"		)		)
										self.assertFalse(_is_control("\r"		)		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										self.assertTrue(_is_punctuation("-"		)		)
										self.assertTrue(_is_punctuation("$"		)		)
										self.assertTrue(_is_punctuation("`"		)		)
										self.assertTrue(_is_punctuation("."		)		)

										self.assertFalse(_is_punctuation("A"		)		)
										self.assertFalse(_is_punctuation(" "		)		)


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						List[Any]       						=			self.get_tokenizer()
										_UpperCAmelCase				:						int       						=			self.get_rust_tokenizer()

										# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
										self.assertListEqual([tokenizer.tokenize(A_		) for t in ["Test", "\xad", "test"]]  ,    [["[UNK]"], [], ["[UNK]"]]		)

										self.assertListEqual(
										    [rust_tokenizer.tokenize(A_		) for t in ["Test", "\xad", "test"]]  ,    [["[UNK]"], [], ["[UNK]"]]		)


						@slow
						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						Optional[Any]       						=			self.tokenizer_class.from_pretrained("google/electra-base-discriminator"		)

										_UpperCAmelCase				:						str       						=			tokenizer.encode("sequence builders"  ,    add_special_tokens=A_		)
										_UpperCAmelCase				:						Dict       						=			tokenizer.encode("multi-sequence build"  ,    add_special_tokens=A_		)

										_UpperCAmelCase				:						Tuple       						=			tokenizer.build_inputs_with_special_tokens(A_		)
										_UpperCAmelCase				:						List[Any]       						=			tokenizer.build_inputs_with_special_tokens(A_  ,    A_		)

										assert encoded_sentence == [101] + text + [102]
										assert encoded_pair == [101] + text + [102] + text_a + [102]


						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
														with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'		):
																		_UpperCAmelCase				:						Union[str, Any]       						=			self.rust_tokenizer_class.from_pretrained(A_  ,    **A_		)

																		_UpperCAmelCase				:						Union[str, Any]       						=			f'A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'
																		_UpperCAmelCase				:						Optional[Any]       						=			tokenizer_r.encode_plus(
																		    A_  ,    return_attention_mask=A_  ,    return_token_type_ids=A_  ,    return_offsets_mapping=A_  ,    add_special_tokens=A_  ,    )

																		_UpperCAmelCase				:						Dict       						=			tokenizer_r.do_lower_case if hasattr(A_  ,    "do_lower_case"		) else False
																		_UpperCAmelCase				:						int       						=			(
																		    [
																		        ((0, 0), tokenizer_r.cls_token),
																		        ((0, 1), "A"),
																		        ((1, 2), ","),
																		        ((3, 5), "na"),
																		        ((5, 6), "##ï"),
																		        ((6, 8), "##ve"),
																		        ((9, 15), tokenizer_r.mask_token),
																		        ((16, 21), "Allen"),
																		        ((21, 23), "##NL"),
																		        ((23, 24), "##P"),
																		        ((25, 33), "sentence"),
																		        ((33, 34), "."),
																		        ((0, 0), tokenizer_r.sep_token),
																		    ]
																		    if not do_lower_case
																		    else [
																		        ((0, 0), tokenizer_r.cls_token),
																		        ((0, 1), "a"),
																		        ((1, 2), ","),
																		        ((3, 8), "naive"),
																		        ((9, 15), tokenizer_r.mask_token),
																		        ((16, 21), "allen"),
																		        ((21, 23), "##nl"),
																		        ((23, 24), "##p"),
																		        ((25, 33), "sentence"),
																		        ((33, 34), "."),
																		        ((0, 0), tokenizer_r.sep_token),
																		    ]
																		)

																		self.assertEqual(
																		    [e[1] for e in expected_results]  ,    tokenizer_r.convert_ids_to_tokens(tokens["input_ids"]		)		)
																		self.assertEqual([e[0] for e in expected_results]  ,    tokens["offset_mapping"]		)





						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


										_UpperCAmelCase				:						List[Any]       						=			["的", "人", "有"]
										_UpperCAmelCase				:						str       						=			"".join(A_		)
										for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
														with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'		):
																		_UpperCAmelCase				:						Tuple       						=			True
																		_UpperCAmelCase				:						List[str]       						=			self.tokenizer_class.from_pretrained(A_  ,    **A_		)
																		_UpperCAmelCase				:						Optional[int]       						=			self.rust_tokenizer_class.from_pretrained(A_  ,    **A_		)

																		_UpperCAmelCase				:						Optional[Any]       						=			tokenizer_p.encode(A_  ,    add_special_tokens=A_		)
																		_UpperCAmelCase				:						Dict       						=			tokenizer_r.encode(A_  ,    add_special_tokens=A_		)

																		_UpperCAmelCase				:						Union[str, Any]       						=			tokenizer_r.convert_ids_to_tokens(A_		)
																		_UpperCAmelCase				:						Tuple       						=			tokenizer_p.convert_ids_to_tokens(A_		)

																		# it is expected that each Chinese character is not preceded by "##"
																		self.assertListEqual(A_  ,    A_		)
																		self.assertListEqual(A_  ,    A_		)

																		_UpperCAmelCase				:						Union[str, Any]       						=			False
																		_UpperCAmelCase				:						int       						=			self.rust_tokenizer_class.from_pretrained(A_  ,    **A_		)
																		_UpperCAmelCase				:						Tuple       						=			self.tokenizer_class.from_pretrained(A_  ,    **A_		)

																		_UpperCAmelCase				:						int       						=			tokenizer_r.encode(A_  ,    add_special_tokens=A_		)
																		_UpperCAmelCase				:						int       						=			tokenizer_p.encode(A_  ,    add_special_tokens=A_		)

																		_UpperCAmelCase				:						List[Any]       						=			tokenizer_r.convert_ids_to_tokens(A_		)
																		_UpperCAmelCase				:						Optional[Any]       						=			tokenizer_p.convert_ids_to_tokens(A_		)

																		# it is expected that only the first Chinese character is not preceded by "##".
																		_UpperCAmelCase				:						Dict       						=			[
																		    f'##{token}' if idx != 0 else token for idx, token in enumerate(A_		)
																		]
																		self.assertListEqual(A_  ,    A_		)
																		self.assertListEqual(A_  ,    A_		)





from __future__ import annotations

class  a     :


						def __init__(				self  ,    A_		):







										'''simple docstring'''


										_UpperCAmelCase				:						List[Any]       						=			vertices
										_UpperCAmelCase				:						List[str]       						=			[[0] * vertices for _ in range(A_		)]


						def 				_UpperCAmelCase (				self  ,    A_		):







										'''simple docstring'''


										print("Vertex \t Distance from Source"		)
										for vertex in range(self.vertices		):
														print(A_  ,    "\t\t"  ,    distances_from_source[vertex]		)


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_		):







										'''simple docstring'''


										_UpperCAmelCase				:						Tuple       						=			1e7
										_UpperCAmelCase				:						Any       						=			0

										# Search not nearest vertex not in the shortest path tree
										for vertex in range(self.vertices		):
														if distances_from_source[vertex] < minimum and visited[vertex] is False:
																		_UpperCAmelCase				:						List[Any]       						=			distances_from_source[vertex]
																		_UpperCAmelCase				:						Tuple       						=			vertex
										return min_index





						def 				_UpperCAmelCase (				self  ,    A_		):







										'''simple docstring'''


										_UpperCAmelCase				:						Union[str, Any]       						=			[int(1e7		)] * self.vertices  # distances from the source
										_UpperCAmelCase				:						Optional[Any]       						=			0
										_UpperCAmelCase				:						List[str]       						=			[False] * self.vertices

										for _ in range(self.vertices		):
														_UpperCAmelCase				:						str       						=			self.minimum_distance(A_  ,    A_		)
														_UpperCAmelCase				:						str       						=			True

														# Update dist value of the adjacent vertices
														# of the picked vertex only if the current
														# distance is greater than new distance and
														# the vertex in not in the shortest path tree
														for v in range(self.vertices		):
																		if (
																		    self.graph[u][v] > 0
																		    and visited[v] is False
																		    and distances[v] > distances[u] + self.graph[u][v]
																		):
																						_UpperCAmelCase				:						str       						=			distances[u] + self.graph[u][v]

										self.print_solution(A_		)


if __name__ == "__main__":
					SCREAMING_SNAKE_CASE_						=					Graph(9)
					SCREAMING_SNAKE_CASE_						=					[
					    [0, 4, 0, 0, 0, 0, 0, 8, 0],
					    [4, 0, 8, 0, 0, 0, 0, 11, 0],
					    [0, 8, 0, 7, 0, 4, 0, 0, 2],
					    [0, 0, 7, 0, 9, 14, 0, 0, 0],
					    [0, 0, 0, 9, 0, 10, 0, 0, 0],
					    [0, 0, 4, 14, 10, 0, 2, 0, 0],
					    [0, 0, 0, 0, 0, 2, 0, 1, 6],
					    [8, 11, 0, 0, 0, 0, 1, 0, 7],
					    [0, 0, 2, 0, 0, 0, 6, 7, 0],
					]
					graph.dijkstra(0)


