





"""simple docstring"""




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 			_lowerCamelCase	(      unittest.TestCase      ):



      """simple docstring"""






      def   UpperCAmelCase						(	self			,  UpperCAmelCase				)    ->				List[Any]:






        '''simple docstring'''






        __snake_case				:			int            =    list(tokenizer_class.max_model_input_sizes.keys()				)
        for model_name in sa_models[:1]:
          __snake_case				:			Optional[Any]            =    tokenizer_class.from_pretrained(UpperCAmelCase				)
          self.assertIsNotNone(UpperCAmelCase				)
          self.assertIsInstance(UpperCAmelCase			,  UpperCAmelCase				)
          self.assertIsInstance(UpperCAmelCase			,  UpperCAmelCase				)

          for special_tok in tokenizer.all_special_tokens:
            self.assertIsInstance(UpperCAmelCase			,  UpperCAmelCase				)
            __snake_case				:			Tuple            =    tokenizer.convert_tokens_to_ids(UpperCAmelCase				)
            self.assertIsInstance(UpperCAmelCase			,  UpperCAmelCase				)







      def   UpperCAmelCase						(	self			,  UpperCAmelCase			,  UpperCAmelCase = None				)    ->				Union[str, Any]:






        '''simple docstring'''






        __snake_case				:			Union[str, Any]            =    pickle.dumps(UpperCAmelCase				)
        self.assertIsNotNone(UpperCAmelCase				)

        __snake_case				:			Optional[int]            =    pickle.loads(UpperCAmelCase				)

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







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






        '''simple docstring'''






        self.check_tokenizer_from_pretrained(UpperCAmelCase				)







      def   UpperCAmelCase						(	self				)    ->				List[Any]:






        '''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

        __snake_case				:			Optional[int]            =    BertTokenizer.from_pretrained("bert-base-cased"				)
        __snake_case				:			Union[str, Any]            =    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				)    ->				Optional[Any]:






        '''simple docstring'''






        import tensorflow as tf

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

        __snake_case				:			int            =    BertTokenizer.from_pretrained("bert-base-cased"				)
        __snake_case				:			List[str]            =    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				)			,  UpperCAmelCase				)

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







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






        '''simple docstring'''






        import torch

        __snake_case				:			List[str]            =    BertTokenizer.from_pretrained("bert-base-cased"				)
        __snake_case				:			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   UpperCAmelCase						(	self				)    ->				int:






        '''simple docstring'''






        __snake_case				:			Optional[Any]            =    BertTokenizer.from_pretrained("bert-base-cased"				)
        __snake_case				:			Optional[Any]            =    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'''






        __snake_case				:			Tuple            =    BertTokenizerFast.from_pretrained("bert-base-cased"				)
        __snake_case				:			str            =    tokenizer_r(["Test", "\xad", "test"]			,  is_split_into_words=UpperCAmelCase				)

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







      def   UpperCAmelCase						(	self				)    ->				Optional[int]:






        '''simple docstring'''






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

        __snake_case				:			List[Any]            =    BatchEncoding({"inputs": [1, 2, 3], "labels": 0}				)
        __snake_case				:			Optional[Any]            =    batch.convert_to_tensors(tensor_type="np"			,  prepend_batch_axis=UpperCAmelCase				)
        self.assertEqual(tensor_batch["inputs"].shape			,  (1, 3)				)
        self.assertEqual(tensor_batch["labels"].shape			,  (1,)				)







      @require_torch
      def   UpperCAmelCase						(	self				)    ->				Optional[Any]:






        '''simple docstring'''






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

        __snake_case				:			List[Any]            =    BatchEncoding({"inputs": [1, 2, 3], "labels": 0}				)
        __snake_case				:			int            =    batch.convert_to_tensors(tensor_type="pt"			,  prepend_batch_axis=UpperCAmelCase				)
        self.assertEqual(tensor_batch["inputs"].shape			,  (1, 3)				)
        self.assertEqual(tensor_batch["labels"].shape			,  (1,)				)







      @require_tf
      def   UpperCAmelCase						(	self				)    ->				str:






        '''simple docstring'''






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

        __snake_case				:			Optional[Any]            =    BatchEncoding({"inputs": [1, 2, 3], "labels": 0}				)
        __snake_case				:			Optional[Any]            =    batch.convert_to_tensors(tensor_type="tf"			,  prepend_batch_axis=UpperCAmelCase				)
        self.assertEqual(tensor_batch["inputs"].shape			,  (1, 3)				)
        self.assertEqual(tensor_batch["labels"].shape			,  (1,)				)







      @require_flax
      def   UpperCAmelCase						(	self				)    ->				Any:






        '''simple docstring'''






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

        __snake_case				:			Optional[Any]            =    BatchEncoding({"inputs": [1, 2, 3], "labels": 0}				)
        __snake_case				:			int            =    batch.convert_to_tensors(tensor_type="jax"			,  prepend_batch_axis=UpperCAmelCase				)
        self.assertEqual(tensor_batch["inputs"].shape			,  (1, 3)				)
        self.assertEqual(tensor_batch["labels"].shape			,  (1,)				)







      def   UpperCAmelCase						(	self				)    ->				Optional[int]:






        '''simple docstring'''






        __snake_case				:			Optional[int]            =    [{"input_ids": np.array([0, 1, 2]				)}, {"input_ids": np.array([0, 1, 2, 3]				)}]
        __snake_case				:			Tuple            =    BertTokenizer.from_pretrained("bert-base-cased"				)

        __snake_case				:			List[str]            =    tokenizer.pad(UpperCAmelCase			,  padding=UpperCAmelCase				)
        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]]				)
        __snake_case				:			Union[str, Any]            =    tokenizer.pad(UpperCAmelCase			,  padding=UpperCAmelCase			,  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

        __snake_case				:			Optional[Any]            =    [{"input_ids": torch.tensor([0, 1, 2]				)}, {"input_ids": torch.tensor([0, 1, 2, 3]				)}]
        __snake_case				:			Optional[int]            =    BertTokenizer.from_pretrained("bert-base-cased"				)

        __snake_case				:			Any            =    tokenizer.pad(UpperCAmelCase			,  padding=UpperCAmelCase				)
        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]]				)
        __snake_case				:			Dict            =    tokenizer.pad(UpperCAmelCase			,  padding=UpperCAmelCase			,  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				)    ->				Optional[int]:






        '''simple docstring'''






        import tensorflow as tf

        __snake_case				:			Union[str, Any]            =    [{"input_ids": tf.constant([0, 1, 2]				)}, {"input_ids": tf.constant([0, 1, 2, 3]				)}]
        __snake_case				:			List[Any]            =    BertTokenizer.from_pretrained("bert-base-cased"				)

        __snake_case				:			Optional[Any]            =    tokenizer.pad(UpperCAmelCase			,  padding=UpperCAmelCase				)
        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]]				)
        __snake_case				:			Optional[Any]            =    tokenizer.pad(UpperCAmelCase			,  padding=UpperCAmelCase			,  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				)    ->				int:






        '''simple docstring'''






        __snake_case				:			List[Any]            =    Tokenizer(WordPiece(unk_token="[UNK]"				)				)
        PreTrainedTokenizerFast(tokenizer_object=UpperCAmelCase				)







      @require_tokenizers
      def   UpperCAmelCase						(	self				)    ->				Optional[Any]:






        '''simple docstring'''






        __snake_case				:			Any            =    Tokenizer(WordPiece(unk_token="[UNK]"				)				)
        with tempfile.TemporaryDirectory() as tmpdirname:
          bert_tokenizer.save(os.path.join(UpperCAmelCase			,  "tokenizer.json"				)				)
          PreTrainedTokenizerFast(tokenizer_file=os.path.join(UpperCAmelCase			,  "tokenizer.json"				)				)








def  lowerCAmelCase__(		lowercase    :      int = 10**6			)	->      int:

  if n <= 0:
    raise ValueError("Please enter an integer greater than 0"			)

  __snake_case				:			List[Any]            =    list(range(n + 1			)			)
  for number in range(2				,       n + 1			):
    if phi[number] == number:
      phi[number] -= 1
      for multiple in range(number * 2				,       n + 1				,       lowercase			):
        __snake_case				:			Optional[int]            =    (phi[multiple] // number) * (number - 1)

  __snake_case				:			List[Any]            =    1
  for number in range(1				,       n + 1			):
    if (answer / phi[answer]) < (number / phi[number]):
      __snake_case				:			List[str]            =    number

  return answer


if __name__ == "__main__":
     print(solution())

