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

 def 		SCREAMING_SNAKE_CASE__     (				self			:							List[str]     ,   snake_case			:							int    )     ->		List[str]:

  """simple docstring"""





  UpperCamelCase_      :		Tuple				=      list(tokenizer_class.max_model_input_sizes.keys()    )
  for model_name in sa_models[:1]:
   UpperCamelCase_      :		int				=      tokenizer_class.from_pretrained(snake_case    )
   self.assertIsNotNone(snake_case    )
   self.assertIsInstance(snake_case     ,   snake_case    )
   self.assertIsInstance(snake_case     ,   snake_case    )

   for special_tok in tokenizer.all_special_tokens:
    self.assertIsInstance(snake_case     ,   snake_case    )
    UpperCamelCase_      :		str				=      tokenizer.convert_tokens_to_ids(snake_case    )
    self.assertIsInstance(snake_case     ,   snake_case    )

 def 		SCREAMING_SNAKE_CASE__     (				self			:							Tuple     ,   snake_case			:							BatchEncoding     ,   snake_case			:							Optional[Callable] = None    )     ->		Union[str, Any]:

  """simple docstring"""





  UpperCamelCase_      :		Dict				=      pickle.dumps(snake_case    )
  self.assertIsNotNone(snake_case    )

  UpperCamelCase_      :		Tuple				=      pickle.loads(snake_case    )

  # 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(snake_case     ,   snake_case    )    )
   else:
    self.assertEqual(snake_case     ,   snake_case    )

 @slow
 def 		SCREAMING_SNAKE_CASE__     (				self			:							Optional[Any]    )     ->		List[str]:

  """simple docstring"""





  self.check_tokenizer_from_pretrained(snake_case    )

 def 		SCREAMING_SNAKE_CASE__     (				self			:							Any    )     ->		Optional[Any]:

  """simple docstring"""





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

 @require_tokenizers
 def 		SCREAMING_SNAKE_CASE__     (				self			:							Tuple    )     ->		str:

  """simple docstring"""





  import numpy as np

  UpperCamelCase_      :		Optional[Any]				=      BertTokenizer.from_pretrained('bert-base-cased'    )
  UpperCamelCase_      :		int				=      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 		SCREAMING_SNAKE_CASE__     (				self			:							Dict    )     ->		List[str]:

  """simple docstring"""





  import tensorflow as tf

  def tf_array_equals(snake_case			:							Optional[int]     ,   snake_case			:							Optional[int]    ):
   return tf.reduce_all(tf.equal(snake_case     ,   snake_case    )    )

  UpperCamelCase_      :		Tuple				=      BertTokenizer.from_pretrained('bert-base-cased'    )
  UpperCamelCase_      :		List[Any]				=      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    )     ,   snake_case    )

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

 @require_torch
 @require_tokenizers
 def 		SCREAMING_SNAKE_CASE__     (				self			:							str    )     ->		Optional[int]:

  """simple docstring"""





  import torch

  UpperCamelCase_      :		int				=      BertTokenizer.from_pretrained('bert-base-cased'    )
  UpperCamelCase_      :		Optional[Any]				=      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 		SCREAMING_SNAKE_CASE__     (				self			:							Optional[int]    )     ->		str:

  """simple docstring"""





  UpperCamelCase_      :		Optional[int]				=      BertTokenizer.from_pretrained('bert-base-cased'    )
  UpperCamelCase_      :		str				=      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 		SCREAMING_SNAKE_CASE__     (				self			:							List[Any]    )     ->		int:

  """simple docstring"""





  UpperCamelCase_      :		Optional[Any]				=      BertTokenizerFast.from_pretrained('bert-base-cased'    )
  UpperCamelCase_      :		Tuple				=      tokenizer_r(['Test', '\xad', 'test']     ,   is_split_into_words=snake_case    )

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

 def 		SCREAMING_SNAKE_CASE__     (				self			:							Union[str, Any]    )     ->		int:

  """simple docstring"""





  UpperCamelCase_      :		Dict				=      BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}    )
  UpperCamelCase_      :		Any				=      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_      :		List[Any]				=      batch.convert_to_tensors(tensor_type='np'    )
  self.assertFalse(len(cs.err    )     ,   msg=f"should have no warning, but got {cs.err}"    )

  UpperCamelCase_      :		Optional[int]				=      BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}    )
  UpperCamelCase_      :		Optional[Any]				=      batch.convert_to_tensors(tensor_type='np'     ,   prepend_batch_axis=snake_case    )
  self.assertEqual(tensor_batch['inputs'].shape     ,   (1, 3)    )
  self.assertEqual(tensor_batch['labels'].shape     ,   (1,)    )

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

  """simple docstring"""





  UpperCamelCase_      :		Union[str, Any]				=      BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}    )
  UpperCamelCase_      :		int				=      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_      :		Optional[int]				=      batch.convert_to_tensors(tensor_type='pt'    )
  self.assertFalse(len(cs.err    )     ,   msg=f"should have no warning, but got {cs.err}"    )

  UpperCamelCase_      :		str				=      BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}    )
  UpperCamelCase_      :		Union[str, Any]				=      batch.convert_to_tensors(tensor_type='pt'     ,   prepend_batch_axis=snake_case    )
  self.assertEqual(tensor_batch['inputs'].shape     ,   (1, 3)    )
  self.assertEqual(tensor_batch['labels'].shape     ,   (1,)    )

 @require_tf
 def 		SCREAMING_SNAKE_CASE__     (				self			:							str    )     ->		Optional[int]:

  """simple docstring"""





  UpperCamelCase_      :		Optional[Any]				=      BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}    )
  UpperCamelCase_      :		Dict				=      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_      :		Dict				=      batch.convert_to_tensors(tensor_type='tf'    )
  self.assertFalse(len(cs.err    )     ,   msg=f"should have no warning, but got {cs.err}"    )

  UpperCamelCase_      :		Tuple				=      BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}    )
  UpperCamelCase_      :		Union[str, Any]				=      batch.convert_to_tensors(tensor_type='tf'     ,   prepend_batch_axis=snake_case    )
  self.assertEqual(tensor_batch['inputs'].shape     ,   (1, 3)    )
  self.assertEqual(tensor_batch['labels'].shape     ,   (1,)    )

 @require_flax
 def 		SCREAMING_SNAKE_CASE__     (				self			:							Dict    )     ->		Optional[int]:

  """simple docstring"""





  UpperCamelCase_      :		Optional[Any]				=      BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}    )
  UpperCamelCase_      :		List[str]				=      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_      :		Optional[int]				=      batch.convert_to_tensors(tensor_type='jax'    )
  self.assertFalse(len(cs.err    )     ,   msg=f"should have no warning, but got {cs.err}"    )

  UpperCamelCase_      :		Optional[Any]				=      BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}    )
  UpperCamelCase_      :		Union[str, Any]				=      batch.convert_to_tensors(tensor_type='jax'     ,   prepend_batch_axis=snake_case    )
  self.assertEqual(tensor_batch['inputs'].shape     ,   (1, 3)    )
  self.assertEqual(tensor_batch['labels'].shape     ,   (1,)    )

 def 		SCREAMING_SNAKE_CASE__     (				self			:							int    )     ->		Tuple:

  """simple docstring"""





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

  UpperCamelCase_      :		Optional[Any]				=      tokenizer.pad(snake_case     ,   padding=snake_case    )
  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_      :		int				=      tokenizer.pad(snake_case     ,   padding=snake_case     ,   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 		SCREAMING_SNAKE_CASE__     (				self			:							Dict    )     ->		Any:

  """simple docstring"""





  import torch

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

  UpperCamelCase_      :		Union[str, Any]				=      tokenizer.pad(snake_case     ,   padding=snake_case    )
  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_      :		Any				=      tokenizer.pad(snake_case     ,   padding=snake_case     ,   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 		SCREAMING_SNAKE_CASE__     (				self			:							Any    )     ->		Optional[Any]:

  """simple docstring"""





  import tensorflow as tf

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

  UpperCamelCase_      :		Dict				=      tokenizer.pad(snake_case     ,   padding=snake_case    )
  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_      :		Union[str, Any]				=      tokenizer.pad(snake_case     ,   padding=snake_case     ,   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 		SCREAMING_SNAKE_CASE__     (				self			:							Dict    )     ->		List[str]:

  """simple docstring"""





  UpperCamelCase_      :		Optional[int]				=      Tokenizer(WordPiece(unk_token='[UNK]'    )    )
  PreTrainedTokenizerFast(tokenizer_object=snake_case    )


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

  """simple docstring"""





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




from __future__ import annotations

from collections import deque
from queue import Queue
from timeit import timeit

a_					      = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E'],
}





def      __lowercase  (		lowerCamelCase      :  dict						,						lowerCamelCase      :  str			):
 UpperCamelCase_      :		Tuple				=      {start}
 UpperCamelCase_      :		Optional[Any]				=      [start]
 UpperCamelCase_      :		Queue				=      Queue()
 queue.put(lowerCamelCase			)
 while not queue.empty():
  UpperCamelCase_      :		Union[str, Any]				=      queue.get()
  for w in graph[v]:
   if w not in explored:
    explored.add(lowerCamelCase			)
    result.append(lowerCamelCase			)
    queue.put(lowerCamelCase			)
 return result





def      __lowercase  (		lowerCamelCase      :  dict						,						lowerCamelCase      :  str			):
 UpperCamelCase_      :		Dict				=      {start}
 UpperCamelCase_      :		Optional[int]				=      [start]
 UpperCamelCase_      :		Union[str, Any]				=      deque([start]			)
 while queue:
  UpperCamelCase_      :		Optional[int]				=      queue.popleft()
  for child in graph[v]:
   if child not in visited:
    visited.add(lowerCamelCase			)
    result.append(lowerCamelCase			)
    queue.append(lowerCamelCase			)
 return result





def      __lowercase  (		lowerCamelCase      :  str			):
 UpperCamelCase_      :		str				=      F"from __main__ import G, {name}"
 UpperCamelCase_      :		int				=      10000
 UpperCamelCase_      :		Optional[Any]				=      timeit(F"{name}(G, 'A')"						,						setup=lowerCamelCase						,						number=lowerCamelCase			)
 print(F"{name:<35} finished {number} runs in {res:.5f} seconds"			)


if __name__ == "__main__":
   import doctest

   doctest.testmod()

   benchmark_function('breadth_first_search')
   benchmark_function('breadth_first_search_with_deque')
   # breadth_first_search                finished 10000 runs in 0.20999 seconds
   # breadth_first_search_with_deque     finished 10000 runs in 0.01421 seconds



