


'''simple docstring'''






import gc
import unittest

from transformers import MODEL_FOR_MASKED_LM_MAPPING, TF_MODEL_FOR_MASKED_LM_MAPPING, FillMaskPipeline, pipeline
from transformers.pipelines import PipelineException
from transformers.testing_utils import (
    is_pipeline_test,
    is_torch_available,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_gpu,
    slow,
)

from .test_pipelines_common import ANY






@is_pipeline_test
class  __magic_name__							(		unittest.TestCase    ):
       UpperCAmelCase										=MODEL_FOR_MASKED_LM_MAPPING
       UpperCAmelCase										=TF_MODEL_FOR_MASKED_LM_MAPPING






       def       lowerCAmelCase		(      self)						->  str:




          '''simple docstring'''
          super().tearDown()
          # clean-up as much as possible GPU memory occupied by PyTorch
          gc.collect()
          if is_torch_available():
             import torch

             torch.cuda.empty_cache()






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




          '''simple docstring'''
          _UpperCAmelCase       :       str							   =pipeline(task='fill-mask'  ,							model='sshleifer/tiny-distilroberta-base'  ,							top_k=2  ,							framework='tf')
          _UpperCAmelCase       :       Union[str, Any]							   =unmasker('My name is <mask>')
          self.assertEqual(
              nested_simplify(snake_case  ,							decimals=6)  ,							[
                  {'sequence': 'My name is grouped', 'score': 2.1E-0_5, 'token': 3_8_0_1_5, 'token_str': ' grouped'},
                  {'sequence': 'My name is accuser', 'score': 2.1E-0_5, 'token': 2_5_5_0_6, 'token_str': ' accuser'},
              ]  ,							)

          _UpperCAmelCase       :       Union[str, Any]							   =unmasker('The largest city in France is <mask>')
          self.assertEqual(
              nested_simplify(snake_case  ,							decimals=6)  ,							[
                  {
                      'sequence': 'The largest city in France is grouped',
                      'score': 2.1E-0_5,
                      'token': 3_8_0_1_5,
                      'token_str': ' grouped',
                  },
                  {
                      'sequence': 'The largest city in France is accuser',
                      'score': 2.1E-0_5,
                      'token': 2_5_5_0_6,
                      'token_str': ' accuser',
                  },
              ]  ,							)

          _UpperCAmelCase       :       Any							   =unmasker('My name is <mask>'  ,							targets=[' Patrick', ' Clara', ' Teven']  ,							top_k=3)
          self.assertEqual(
              nested_simplify(snake_case  ,							decimals=6)  ,							[
                  {'sequence': 'My name is Clara', 'score': 2E-0_5, 'token': 1_3_6_0_6, 'token_str': ' Clara'},
                  {'sequence': 'My name is Patrick', 'score': 2E-0_5, 'token': 3_4_9_9, 'token_str': ' Patrick'},
                  {'sequence': 'My name is Te', 'score': 1.9E-0_5, 'token': 2_9_4_1, 'token_str': ' Te'},
              ]  ,							)






       @require_torch
       def       lowerCAmelCase		(      self)						->  List[Any]:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[Any]							   =pipeline(task='fill-mask'  ,							model='sshleifer/tiny-distilroberta-base'  ,							top_k=2  ,							framework='pt')

          _UpperCAmelCase       :       Optional[int]							   =unmasker('My name is <mask>')
          self.assertEqual(
              nested_simplify(snake_case  ,							decimals=6)  ,							[
                  {'sequence': 'My name is Maul', 'score': 2.2E-0_5, 'token': 3_5_6_7_6, 'token_str': ' Maul'},
                  {'sequence': 'My name isELS', 'score': 2.2E-0_5, 'token': 1_6_4_1_6, 'token_str': 'ELS'},
              ]  ,							)

          _UpperCAmelCase       :       Union[str, Any]							   =unmasker('The largest city in France is <mask>')
          self.assertEqual(
              nested_simplify(snake_case  ,							decimals=6)  ,							[
                  {
                      'sequence': 'The largest city in France is Maul',
                      'score': 2.2E-0_5,
                      'token': 3_5_6_7_6,
                      'token_str': ' Maul',
                  },
                  {'sequence': 'The largest city in France isELS', 'score': 2.2E-0_5, 'token': 1_6_4_1_6, 'token_str': 'ELS'},
              ]  ,							)

          _UpperCAmelCase       :       str							   =unmasker('My name is <mask>'  ,							targets=[' Patrick', ' Clara', ' Teven']  ,							top_k=3)
          self.assertEqual(
              nested_simplify(snake_case  ,							decimals=6)  ,							[
                  {'sequence': 'My name is Patrick', 'score': 2.1E-0_5, 'token': 3_4_9_9, 'token_str': ' Patrick'},
                  {'sequence': 'My name is Te', 'score': 2E-0_5, 'token': 2_9_4_1, 'token_str': ' Te'},
                  {'sequence': 'My name is Clara', 'score': 2E-0_5, 'token': 1_3_6_0_6, 'token_str': ' Clara'},
              ]  ,							)

          _UpperCAmelCase       :       Dict							   =unmasker('My name is <mask> <mask>'  ,							top_k=2)

          self.assertEqual(
              nested_simplify(snake_case  ,							decimals=6)  ,							[
                  [
                      {
                          'score': 2.2E-0_5,
                          'token': 3_5_6_7_6,
                          'token_str': ' Maul',
                          'sequence': '<s>My name is Maul<mask></s>',
                      },
                      {'score': 2.2E-0_5, 'token': 1_6_4_1_6, 'token_str': 'ELS', 'sequence': '<s>My name isELS<mask></s>'},
                  ],
                  [
                      {
                          'score': 2.2E-0_5,
                          'token': 3_5_6_7_6,
                          'token_str': ' Maul',
                          'sequence': '<s>My name is<mask> Maul</s>',
                      },
                      {'score': 2.2E-0_5, 'token': 1_6_4_1_6, 'token_str': 'ELS', 'sequence': '<s>My name is<mask>ELS</s>'},
                  ],
              ]  ,							)






       @require_torch_gpu
       def       lowerCAmelCase		(      self)						->  int:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[Any]							   =pipeline('fill-mask'  ,							model='hf-internal-testing/tiny-random-distilbert'  ,							device=0  ,							framework='pt')

          # convert model to fp16
          pipe.model.half()

          _UpperCAmelCase       :       Optional[Any]							   =pipe('Paris is the [MASK] of France.')
          # We actually don't care about the result, we just want to make sure
          # it works, meaning the float16 tensor got casted back to float32
          # for postprocessing.
          self.assertIsInstance(snake_case  ,							snake_case)






       @slow
       @require_torch
       def       lowerCAmelCase		(      self)						->  Dict:




          '''simple docstring'''
          _UpperCAmelCase       :       int							   =pipeline(task='fill-mask'  ,							model='distilroberta-base'  ,							top_k=2  ,							framework='pt')
          self.run_large_test(snake_case)






       @slow
       @require_tf
       def       lowerCAmelCase		(      self)						->  Tuple:




          '''simple docstring'''
          _UpperCAmelCase       :       Union[str, Any]							   =pipeline(task='fill-mask'  ,							model='distilroberta-base'  ,							top_k=2  ,							framework='tf')
          self.run_large_test(snake_case)






       def       lowerCAmelCase		(      self  ,							snake_case)						->  str:




          '''simple docstring'''
          _UpperCAmelCase       :       str							   =unmasker('My name is <mask>')
          self.assertEqual(
              nested_simplify(snake_case)  ,							[
                  {'sequence': 'My name is John', 'score': 0.0_08, 'token': 6_1_0, 'token_str': ' John'},
                  {'sequence': 'My name is Chris', 'score': 0.0_07, 'token': 1_5_7_3, 'token_str': ' Chris'},
              ]  ,							)
          _UpperCAmelCase       :       str							   =unmasker('The largest city in France is <mask>')
          self.assertEqual(
              nested_simplify(snake_case)  ,							[
                  {
                      'sequence': 'The largest city in France is Paris',
                      'score': 0.2_51,
                      'token': 2_2_0_1,
                      'token_str': ' Paris',
                  },
                  {
                      'sequence': 'The largest city in France is Lyon',
                      'score': 0.2_14,
                      'token': 1_2_7_9_0,
                      'token_str': ' Lyon',
                  },
              ]  ,							)

          _UpperCAmelCase       :       Union[str, Any]							   =unmasker('My name is <mask>'  ,							targets=[' Patrick', ' Clara', ' Teven']  ,							top_k=3)
          self.assertEqual(
              nested_simplify(snake_case)  ,							[
                  {'sequence': 'My name is Patrick', 'score': 0.0_05, 'token': 3_4_9_9, 'token_str': ' Patrick'},
                  {'sequence': 'My name is Clara', 'score': 0.0_00, 'token': 1_3_6_0_6, 'token_str': ' Clara'},
                  {'sequence': 'My name is Te', 'score': 0.0_00, 'token': 2_9_4_1, 'token_str': ' Te'},
              ]  ,							)






       @require_torch
       def       lowerCAmelCase		(      self)						->  Tuple:




          '''simple docstring'''
          _UpperCAmelCase       :       Tuple							   =pipeline(task='fill-mask'  ,							model='sshleifer/tiny-distilroberta-base'  ,							framework='pt')
          _UpperCAmelCase       :       Optional[Any]							   =None
          _UpperCAmelCase       :       List[str]							   =None
          self.run_pipeline_test(snake_case  ,							[])






       @require_tf
       def       lowerCAmelCase		(      self)						->  Optional[Any]:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[int]							   =pipeline(task='fill-mask'  ,							model='sshleifer/tiny-distilroberta-base'  ,							framework='tf')
          _UpperCAmelCase       :       List[Any]							   =None
          _UpperCAmelCase       :       str							   =None
          self.run_pipeline_test(snake_case  ,							[])






       def       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case  ,							snake_case)						->  Union[str, Any]:




          '''simple docstring'''
          if tokenizer is None or tokenizer.mask_token_id is None:
             self.skipTest('The provided tokenizer has no mask token, (probably reformer or wav2vec2)')

          _UpperCAmelCase       :       Optional[int]							   =FillMaskPipeline(model=snake_case  ,							tokenizer=snake_case)
          _UpperCAmelCase       :       Optional[int]							   =[
              f"This is another {tokenizer.mask_token} test",
          ]
          return fill_masker, examples






       def       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case)						->  str:




          '''simple docstring'''
          _UpperCAmelCase       :       Optional[int]							   =fill_masker.tokenizer
          _UpperCAmelCase       :       int							   =fill_masker.model

          _UpperCAmelCase       :       List[str]							   =fill_masker(
              f"This is a {tokenizer.mask_token}"  ,							)
          self.assertEqual(
              snake_case  ,							[
                  {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                  {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                  {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                  {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                  {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
              ]  ,							)

          _UpperCAmelCase       :       Optional[Any]							   =fill_masker([f"This is a {tokenizer.mask_token}"])
          self.assertEqual(
              snake_case  ,							[
                  {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                  {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                  {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                  {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                  {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
              ]  ,							)

          _UpperCAmelCase       :       str							   =fill_masker([f"This is a {tokenizer.mask_token}", f"Another {tokenizer.mask_token} great test."])
          self.assertEqual(
              snake_case  ,							[
                  [
                      {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                      {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                      {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                      {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                      {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                  ],
                  [
                      {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                      {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                      {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                      {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                      {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                  ],
              ]  ,							)

          with self.assertRaises(snake_case):
             fill_masker([None])
          # No mask_token is not supported
          with self.assertRaises(snake_case):
             fill_masker('This is')

          self.run_test_top_k(snake_case  ,							snake_case)
          self.run_test_targets(snake_case  ,							snake_case)
          self.run_test_top_k_targets(snake_case  ,							snake_case)
          self.fill_mask_with_duplicate_targets_and_top_k(snake_case  ,							snake_case)
          self.fill_mask_with_multiple_masks(snake_case  ,							snake_case)






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




          '''simple docstring'''
          _UpperCAmelCase       :       Tuple							   =tokenizer.get_vocab()
          _UpperCAmelCase       :       List[str]							   =sorted(vocab.keys())[:2]
          # Pipeline argument
          _UpperCAmelCase       :       str							   =FillMaskPipeline(model=snake_case  ,							tokenizer=snake_case  ,							targets=snake_case)
          _UpperCAmelCase       :       Optional[int]							   =fill_masker(f"This is a {tokenizer.mask_token}")
          self.assertEqual(
              snake_case  ,							[
                  {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                  {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
              ]  ,							)
          _UpperCAmelCase       :       Tuple							   ={vocab[el] for el in targets}
          self.assertEqual({el['token'] for el in outputs}  ,							snake_case)
          _UpperCAmelCase       :       Optional[Any]							   =[tokenizer.decode([x]) for x in target_ids]
          self.assertEqual({el['token_str'] for el in outputs}  ,							set(snake_case))

          # Call argument
          _UpperCAmelCase       :       int							   =FillMaskPipeline(model=snake_case  ,							tokenizer=snake_case)
          _UpperCAmelCase       :       int							   =fill_masker(f"This is a {tokenizer.mask_token}"  ,							targets=snake_case)
          self.assertEqual(
              snake_case  ,							[
                  {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                  {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
              ]  ,							)
          _UpperCAmelCase       :       Union[str, Any]							   ={vocab[el] for el in targets}
          self.assertEqual({el['token'] for el in outputs}  ,							snake_case)
          _UpperCAmelCase       :       str							   =[tokenizer.decode([x]) for x in target_ids]
          self.assertEqual({el['token_str'] for el in outputs}  ,							set(snake_case))

          # Score equivalence
          _UpperCAmelCase       :       Any							   =fill_masker(f"This is a {tokenizer.mask_token}"  ,							targets=snake_case)
          _UpperCAmelCase       :       Any							   =[top_mask['token_str'] for top_mask in outputs]
          _UpperCAmelCase       :       int							   =[top_mask['score'] for top_mask in outputs]

          # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
          if set(snake_case) == set(snake_case):
             _UpperCAmelCase       :       Tuple							   =fill_masker(f"This is a {tokenizer.mask_token}"  ,							targets=snake_case)
             _UpperCAmelCase       :       Dict							   =[top_mask['score'] for top_mask in unmasked_targets]
             self.assertEqual(nested_simplify(snake_case)  ,							nested_simplify(snake_case))

          # Raises with invalid
          with self.assertRaises(snake_case):
             _UpperCAmelCase       :       str							   =fill_masker(f"This is a {tokenizer.mask_token}"  ,							targets=[])
          # For some tokenizers, `""` is actually in the vocabulary and the expected error won't raised
          if "" not in tokenizer.get_vocab():
             with self.assertRaises(snake_case):
                _UpperCAmelCase       :       Dict							   =fill_masker(f"This is a {tokenizer.mask_token}"  ,							targets=[''])
             with self.assertRaises(snake_case):
                _UpperCAmelCase       :       Union[str, Any]							   =fill_masker(f"This is a {tokenizer.mask_token}"  ,							targets='')






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




          '''simple docstring'''
          _UpperCAmelCase       :       str							   =FillMaskPipeline(model=snake_case  ,							tokenizer=snake_case  ,							top_k=2)
          _UpperCAmelCase       :       Union[str, Any]							   =fill_masker(f"This is a {tokenizer.mask_token}")
          self.assertEqual(
              snake_case  ,							[
                  {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                  {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
              ]  ,							)

          _UpperCAmelCase       :       Any							   =FillMaskPipeline(model=snake_case  ,							tokenizer=snake_case)
          _UpperCAmelCase       :       Union[str, Any]							   =fill_masker(f"This is a {tokenizer.mask_token}"  ,							top_k=2)
          self.assertEqual(
              snake_case  ,							[
                  {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                  {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
              ]  ,							)
          self.assertEqual(nested_simplify(snake_case)  ,							nested_simplify(snake_case))






       def       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case)						->  Optional[Any]:




          '''simple docstring'''
          _UpperCAmelCase       :       Tuple							   =tokenizer.get_vocab()
          _UpperCAmelCase       :       List[Any]							   =FillMaskPipeline(model=snake_case  ,							tokenizer=snake_case)

          # top_k=2, ntargets=3
          _UpperCAmelCase       :       Optional[Any]							   =sorted(vocab.keys())[:3]
          _UpperCAmelCase       :       Optional[Any]							   =fill_masker(f"This is a {tokenizer.mask_token}"  ,							top_k=2  ,							targets=snake_case)

          # If we use the most probably targets, and filter differently, we should still
          # have the same results
          _UpperCAmelCase       :       List[Any]							   =[el['token_str'] for el in sorted(snake_case  ,							key=lambda snake_case: x["score"]  ,							reverse=snake_case)]
          # For some BPE tokenizers, `</w>` is removed during decoding, so `token_str` won't be the same as in `targets`.
          if set(snake_case).issubset(snake_case):
             _UpperCAmelCase       :       str							   =fill_masker(f"This is a {tokenizer.mask_token}"  ,							top_k=3  ,							targets=snake_case)
             # They should yield exactly the same result
             self.assertEqual(nested_simplify(snake_case)  ,							nested_simplify(snake_case))






       def       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case)						->  Tuple:




          '''simple docstring'''
          _UpperCAmelCase       :       List[str]							   =FillMaskPipeline(model=snake_case  ,							tokenizer=snake_case)
          _UpperCAmelCase       :       Dict							   =tokenizer.get_vocab()
          # String duplicates + id duplicates
          _UpperCAmelCase       :       List[Any]							   =sorted(vocab.keys())[:3]
          _UpperCAmelCase       :       Tuple							   =[targets[0], targets[1], targets[0], targets[2], targets[1]]
          _UpperCAmelCase       :       Optional[int]							   =fill_masker(f"My name is {tokenizer.mask_token}"  ,							targets=snake_case  ,							top_k=1_0)

          # The target list contains duplicates, so we can't output more
          # than them
          self.assertEqual(len(snake_case)  ,							3)






       def       lowerCAmelCase		(      self  ,							snake_case  ,							snake_case)						->  Optional[Any]:




          '''simple docstring'''
          _UpperCAmelCase       :       str							   =FillMaskPipeline(model=snake_case  ,							tokenizer=snake_case)

          _UpperCAmelCase       :       List[str]							   =fill_masker(
              f"This is a {tokenizer.mask_token} {tokenizer.mask_token} {tokenizer.mask_token}"  ,							top_k=2)
          self.assertEqual(
              snake_case  ,							[
                  [
                      {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                      {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                  ],
                  [
                      {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                      {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                  ],
                  [
                      {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                      {'sequence': ANY(snake_case), 'score': ANY(snake_case), 'token': ANY(snake_case), 'token_str': ANY(snake_case)},
                  ],
              ]  ,							)





'''simple docstring'''






from string import ascii_uppercase

lowercase							={str(ord(c) - 55): c for c in ascii_uppercase}





def lowerCamelCase__      (						__lowerCamelCase	:							int	,   __lowerCamelCase	:							int							):







   '''simple docstring'''




   if isinstance(__lowerCamelCase	,   __lowerCamelCase							):
      raise TypeError('int() can\'t convert non-string with explicit base'							)
   if num < 0:
      raise ValueError('parameter must be positive int'							)
   if isinstance(__lowerCamelCase	,   __lowerCamelCase							):
      raise TypeError('\'str\' object cannot be interpreted as an integer'							)
   if isinstance(__lowerCamelCase	,   __lowerCamelCase							):
      raise TypeError('\'float\' object cannot be interpreted as an integer'							)
   if base in (0, 1):
      raise ValueError('base must be >= 2'							)
   if base > 3_6:
      raise ValueError('base must be <= 36'							)
   _UpperCAmelCase       :       Union[str, Any]							   =''
   _UpperCAmelCase       :       Optional[int]							   =0
   _UpperCAmelCase       :       str							   =0
   while div != 1:
      _UpperCAmelCase   ,	_UpperCAmelCase       :       int							   =divmod(__lowerCamelCase	,   __lowerCamelCase							)
      if base >= 1_1 and 9 < mod < 3_6:
         _UpperCAmelCase       :       str							   =ALPHABET_VALUES[str(__lowerCamelCase							)]
      else:
         _UpperCAmelCase       :       Any							   =str(__lowerCamelCase							)
      new_value += actual_value
      _UpperCAmelCase       :       Union[str, Any]							   =num // base
      _UpperCAmelCase       :       Dict							   =div
      if div == 0:
         return str(new_value[::-1]							)
      elif div == 1:
         new_value += str(__lowerCamelCase							)
         return str(new_value[::-1]							)

   return new_value[::-1]


if __name__ == "__main__":
 import doctest

 doctest.testmod()

 for base in range(2, 37):
  for num in range(1000):
   assert int(decimal_to_any(num, base), base) == num, (
       num,
       base,
       decimal_to_any(num, base),
       int(decimal_to_any(num, base), base),
   )

