

import os
import pickle
import tempfile
import unittest
from typing import Callable, Optional

import numpy as np

from transformers import (
    BatchEncoding,
    BertTokenizer,
    BertTokenizerFast,
    PreTrainedTokenizer,
    PreTrainedTokenizerFast,
    TensorType,
    TokenSpan,
    is_tokenizers_available,
)
from transformers.models.gpta.tokenization_gpta import GPTaTokenizer
from transformers.testing_utils import CaptureStderr, require_flax, require_tf, require_tokenizers, require_torch, slow


if is_tokenizers_available():
 from tokenizers import Tokenizer
 from tokenizers.models import WordPiece



class 					lowercase		( unittest.TestCase      ):



 '''simple docstring'''


 def 						UpperCamelCase__							(self , __a				)				->      Union[str, Any]:






  """simple docstring"""





  UpperCAmelCase__           =       list(tokenizer_class.max_model_input_sizes.keys()				)
  for model_name in sa_models[:1]:
   UpperCAmelCase__           =       tokenizer_class.from_pretrained(__a				)
   self.assertIsNotNone(__a				)
   self.assertIsInstance(__a , __a				)
   self.assertIsInstance(__a , __a				)

   for special_tok in tokenizer.all_special_tokens:
    self.assertIsInstance(__a , __a				)
    UpperCAmelCase__           =       tokenizer.convert_tokens_to_ids(__a				)
    self.assertIsInstance(__a , __a				)




 def 						UpperCamelCase__							(self , __a , __a = None				)				->      Dict:






  """simple docstring"""





  UpperCAmelCase__           =       pickle.dumps(__a				)
  self.assertIsNotNone(__a				)

  UpperCAmelCase__           =       pickle.loads(__a				)

  # Ensure is_fast is correctly restored
  self.assertEqual(be_restored.is_fast , be_original.is_fast				)

  # Ensure encodings are potentially correctly restored
  if be_original.is_fast:
   self.assertIsNotNone(be_restored.encodings				)
  else:
   self.assertIsNone(be_restored.encodings				)

  # Ensure the keys are the same
  for original_v, restored_v in zip(be_original.values() , be_restored.values()				):
   if equal_op:
    self.assertTrue(equal_op(__a , __a				)				)
   else:
    self.assertEqual(__a , __a				)




 @slow
 def 						UpperCamelCase__							(self				)				->      Optional[int]:






  """simple docstring"""





  self.check_tokenizer_from_pretrained(__a				)




 def 						UpperCamelCase__							(self				)				->      str:






  """simple docstring"""





  self.assertEqual(TensorType('tf'				) , TensorType.TENSORFLOW				)
  self.assertEqual(TensorType('pt'				) , TensorType.PYTORCH				)
  self.assertEqual(TensorType('np'				) , TensorType.NUMPY				)




 @require_tokenizers
 def 						UpperCamelCase__							(self				)				->      List[str]:






  """simple docstring"""





  import numpy as np

  UpperCAmelCase__           =       BertTokenizer.from_pretrained('bert-base-cased'				)
  UpperCAmelCase__           =       BertTokenizerFast.from_pretrained('bert-base-cased'				)

  # Python no tensor
  with self.subTest('BatchEncoding (Python, return_tensors=None)'				):
   self.assert_dump_and_restore(tokenizer_p('Small example to encode'				)				)

  with self.subTest('BatchEncoding (Python, return_tensors=NUMPY)'				):
   self.assert_dump_and_restore(
       tokenizer_p('Small example to encode' , return_tensors=TensorType.NUMPY				) , np.array_equal				)

  with self.subTest('BatchEncoding (Rust, return_tensors=None)'				):
   self.assert_dump_and_restore(tokenizer_r('Small example to encode'				)				)

  with self.subTest('BatchEncoding (Rust, return_tensors=NUMPY)'				):
   self.assert_dump_and_restore(
       tokenizer_r('Small example to encode' , return_tensors=TensorType.NUMPY				) , np.array_equal				)




 @require_tf
 @require_tokenizers
 def 						UpperCamelCase__							(self				)				->      Tuple:






  """simple docstring"""





  import tensorflow as tf

  def tf_array_equals(__a , __a				):
   return tf.reduce_all(tf.equal(__a , __a				)				)

  UpperCAmelCase__           =       BertTokenizer.from_pretrained('bert-base-cased'				)
  UpperCAmelCase__           =       BertTokenizerFast.from_pretrained('bert-base-cased'				)

  with self.subTest('BatchEncoding (Python, return_tensors=TENSORFLOW)'				):
   self.assert_dump_and_restore(
       tokenizer_p('Small example to encode' , return_tensors=TensorType.TENSORFLOW				) , __a				)

  with self.subTest('BatchEncoding (Rust, return_tensors=TENSORFLOW)'				):
   self.assert_dump_and_restore(
       tokenizer_r('Small example to encode' , return_tensors=TensorType.TENSORFLOW				) , __a				)




 @require_torch
 @require_tokenizers
 def 						UpperCamelCase__							(self				)				->      Any:






  """simple docstring"""





  import torch

  UpperCAmelCase__           =       BertTokenizer.from_pretrained('bert-base-cased'				)
  UpperCAmelCase__           =       BertTokenizerFast.from_pretrained('bert-base-cased'				)

  with self.subTest('BatchEncoding (Python, return_tensors=PYTORCH)'				):
   self.assert_dump_and_restore(
       tokenizer_p('Small example to encode' , return_tensors=TensorType.PYTORCH				) , torch.equal				)

  with self.subTest('BatchEncoding (Rust, return_tensors=PYTORCH)'				):
   self.assert_dump_and_restore(
       tokenizer_r('Small example to encode' , return_tensors=TensorType.PYTORCH				) , torch.equal				)




 @require_tokenizers
 def 						UpperCamelCase__							(self				)				->      Dict:






  """simple docstring"""





  UpperCAmelCase__           =       BertTokenizer.from_pretrained('bert-base-cased'				)
  UpperCAmelCase__           =       BertTokenizerFast.from_pretrained('bert-base-cased'				)

  with self.subTest('Python Tokenizer'				):
   self.assertFalse(tokenizer_p('Small example to_encode'				).is_fast				)

  with self.subTest('Rust Tokenizer'				):
   self.assertTrue(tokenizer_r('Small example to_encode'				).is_fast				)




 @require_tokenizers
 def 						UpperCamelCase__							(self				)				->      List[Any]:






  """simple docstring"""





  UpperCAmelCase__           =       BertTokenizerFast.from_pretrained('bert-base-cased'				)
  UpperCAmelCase__           =       tokenizer_r(['Test', '\xad', 'test'] , is_split_into_words=__a				)

  self.assertEqual(encoded.word_to_tokens(0				) , TokenSpan(start=1 , end=2				)				)
  self.assertEqual(encoded.word_to_tokens(1				) , __a				)
  self.assertEqual(encoded.word_to_tokens(2				) , TokenSpan(start=2 , end=3				)				)




 def 						UpperCamelCase__							(self				)				->      Dict:






  """simple docstring"""





  UpperCAmelCase__           =       BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}				)
  UpperCAmelCase__           =       batch.convert_to_tensors(tensor_type='np'				)
  self.assertEqual(tensor_batch['inputs'].shape , (2, 3)				)
  self.assertEqual(tensor_batch['labels'].shape , (2,)				)
  # test converting the converted
  with CaptureStderr() as cs:
   UpperCAmelCase__           =       batch.convert_to_tensors(tensor_type='np'				)
  self.assertFalse(len(cs.err				) , msg=F"should have no warning, but got {cs.err}"				)

  UpperCAmelCase__           =       BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}				)
  UpperCAmelCase__           =       batch.convert_to_tensors(tensor_type='np' , prepend_batch_axis=__a				)
  self.assertEqual(tensor_batch['inputs'].shape , (1, 3)				)
  self.assertEqual(tensor_batch['labels'].shape , (1,)				)




 @require_torch
 def 						UpperCamelCase__							(self				)				->      List[str]:






  """simple docstring"""





  UpperCAmelCase__           =       BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}				)
  UpperCAmelCase__           =       batch.convert_to_tensors(tensor_type='pt'				)
  self.assertEqual(tensor_batch['inputs'].shape , (2, 3)				)
  self.assertEqual(tensor_batch['labels'].shape , (2,)				)
  # test converting the converted
  with CaptureStderr() as cs:
   UpperCAmelCase__           =       batch.convert_to_tensors(tensor_type='pt'				)
  self.assertFalse(len(cs.err				) , msg=F"should have no warning, but got {cs.err}"				)

  UpperCAmelCase__           =       BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}				)
  UpperCAmelCase__           =       batch.convert_to_tensors(tensor_type='pt' , prepend_batch_axis=__a				)
  self.assertEqual(tensor_batch['inputs'].shape , (1, 3)				)
  self.assertEqual(tensor_batch['labels'].shape , (1,)				)




 @require_tf
 def 						UpperCamelCase__							(self				)				->      Union[str, Any]:






  """simple docstring"""





  UpperCAmelCase__           =       BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}				)
  UpperCAmelCase__           =       batch.convert_to_tensors(tensor_type='tf'				)
  self.assertEqual(tensor_batch['inputs'].shape , (2, 3)				)
  self.assertEqual(tensor_batch['labels'].shape , (2,)				)
  # test converting the converted
  with CaptureStderr() as cs:
   UpperCAmelCase__           =       batch.convert_to_tensors(tensor_type='tf'				)
  self.assertFalse(len(cs.err				) , msg=F"should have no warning, but got {cs.err}"				)

  UpperCAmelCase__           =       BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}				)
  UpperCAmelCase__           =       batch.convert_to_tensors(tensor_type='tf' , prepend_batch_axis=__a				)
  self.assertEqual(tensor_batch['inputs'].shape , (1, 3)				)
  self.assertEqual(tensor_batch['labels'].shape , (1,)				)




 @require_flax
 def 						UpperCamelCase__							(self				)				->      int:






  """simple docstring"""





  UpperCAmelCase__           =       BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}				)
  UpperCAmelCase__           =       batch.convert_to_tensors(tensor_type='jax'				)
  self.assertEqual(tensor_batch['inputs'].shape , (2, 3)				)
  self.assertEqual(tensor_batch['labels'].shape , (2,)				)
  # test converting the converted
  with CaptureStderr() as cs:
   UpperCAmelCase__           =       batch.convert_to_tensors(tensor_type='jax'				)
  self.assertFalse(len(cs.err				) , msg=F"should have no warning, but got {cs.err}"				)

  UpperCAmelCase__           =       BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}				)
  UpperCAmelCase__           =       batch.convert_to_tensors(tensor_type='jax' , prepend_batch_axis=__a				)
  self.assertEqual(tensor_batch['inputs'].shape , (1, 3)				)
  self.assertEqual(tensor_batch['labels'].shape , (1,)				)




 def 						UpperCamelCase__							(self				)				->      Any:






  """simple docstring"""





  UpperCAmelCase__           =       [{'input_ids': np.array([0, 1, 2]				)}, {'input_ids': np.array([0, 1, 2, 3]				)}]
  UpperCAmelCase__           =       BertTokenizer.from_pretrained('bert-base-cased'				)

  UpperCAmelCase__           =       tokenizer.pad(__a , padding=__a				)
  self.assertTrue(isinstance(batch['input_ids'] , np.ndarray				)				)
  self.assertEqual(batch['input_ids'].tolist() , [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]				)
  UpperCAmelCase__           =       tokenizer.pad(__a , padding=__a , return_tensors='np'				)
  self.assertTrue(isinstance(batch['input_ids'] , np.ndarray				)				)
  self.assertEqual(batch['input_ids'].tolist() , [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]				)




 @require_torch
 def 						UpperCamelCase__							(self				)				->      Any:






  """simple docstring"""





  import torch

  UpperCAmelCase__           =       [{'input_ids': torch.tensor([0, 1, 2]				)}, {'input_ids': torch.tensor([0, 1, 2, 3]				)}]
  UpperCAmelCase__           =       BertTokenizer.from_pretrained('bert-base-cased'				)

  UpperCAmelCase__           =       tokenizer.pad(__a , padding=__a				)
  self.assertTrue(isinstance(batch['input_ids'] , torch.Tensor				)				)
  self.assertEqual(batch['input_ids'].tolist() , [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]				)
  UpperCAmelCase__           =       tokenizer.pad(__a , padding=__a , return_tensors='pt'				)
  self.assertTrue(isinstance(batch['input_ids'] , torch.Tensor				)				)
  self.assertEqual(batch['input_ids'].tolist() , [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]				)




 @require_tf
 def 						UpperCamelCase__							(self				)				->      Any:






  """simple docstring"""





  import tensorflow as tf

  UpperCAmelCase__           =       [{'input_ids': tf.constant([0, 1, 2]				)}, {'input_ids': tf.constant([0, 1, 2, 3]				)}]
  UpperCAmelCase__           =       BertTokenizer.from_pretrained('bert-base-cased'				)

  UpperCAmelCase__           =       tokenizer.pad(__a , padding=__a				)
  self.assertTrue(isinstance(batch['input_ids'] , tf.Tensor				)				)
  self.assertEqual(batch['input_ids'].numpy().tolist() , [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]				)
  UpperCAmelCase__           =       tokenizer.pad(__a , padding=__a , return_tensors='tf'				)
  self.assertTrue(isinstance(batch['input_ids'] , tf.Tensor				)				)
  self.assertEqual(batch['input_ids'].numpy().tolist() , [[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]				)




 @require_tokenizers
 def 						UpperCamelCase__							(self				)				->      Union[str, Any]:






  """simple docstring"""





  UpperCAmelCase__           =       Tokenizer(WordPiece(unk_token='[UNK]'				)				)
  PreTrainedTokenizerFast(tokenizer_object=__a				)




 @require_tokenizers
 def 						UpperCamelCase__							(self				)				->      List[Any]:






  """simple docstring"""





  UpperCAmelCase__           =       Tokenizer(WordPiece(unk_token='[UNK]'				)				)
  with tempfile.TemporaryDirectory() as tmpdirname:
   bert_tokenizer.save(os.path.join(__a , 'tokenizer.json'				)				)
   PreTrainedTokenizerFast(tokenizer_file=os.path.join(__a , 'tokenizer.json'				)				)






from __future__ import annotations



class 					lowercase		:



 '''simple docstring'''


 def __init__(self , __a				)				->      None:






  """simple docstring"""





  UpperCAmelCase__           =       vertices
  UpperCAmelCase__           =       [[0] * vertices for _ in range(__a				)]




 def 						UpperCamelCase__							(self , __a				)				->      None:






  """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				)				->      int:






  """simple docstring"""





  UpperCAmelCase__           =       1E7
  UpperCAmelCase__           =       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__           =       distances_from_source[vertex]
    UpperCAmelCase__           =       vertex
  return min_index




 def 						UpperCamelCase__							(self , __a				)				->      None:






  """simple docstring"""





  UpperCAmelCase__           =       [int(1E7				)] * self.vertices  # distances from the source
  UpperCAmelCase__           =       0
  UpperCAmelCase__           =       [False] * self.vertices

  for _ in range(self.vertices				):
   UpperCAmelCase__           =       self.minimum_distance(__a , __a				)
   UpperCAmelCase__           =       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__           =       distances[u] + self.graph[u][v]

  self.print_solution(__a				)


if __name__ == "__main__":
 _UpperCamelCase     =    Graph(9)
 _UpperCamelCase     =    [
     [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)



