"""simple docstring"""







import shutil
import tempfile
import unittest

from transformers import (
    SPIECE_UNDERLINE,
    AddedToken,
    BatchEncoding,
    NllbTokenizer,
    NllbTokenizerFast,
    is_torch_available,
)
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


__SCREAMING_SNAKE_CASE								=get_tests_dir("fixtures/test_sentencepiece.model")


if is_torch_available():
       from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right

__SCREAMING_SNAKE_CASE								=25_6047
__SCREAMING_SNAKE_CASE								=25_6145







@require_sentencepiece
@require_tokenizers
class  UpperCamelCase	(    lowercase_		,   unittest.TestCase						):
   lowercase							=						NllbTokenizer
   lowercase							=						NllbTokenizerFast
   lowercase							=						True
   lowercase							=						True
   lowercase							=						{}
   def     _UpperCAmelCase     (    self    )			->   int:


        '''simple docstring'''


        super().setUp()

        # We have a SentencePiece fixture for testing
        lowercase_			:       int									=			NllbTokenizer(__UpperCamelCase  ,keep_accents=__UpperCamelCase    )
        tokenizer.save_pretrained(self.tmpdirname    )
   def     _UpperCAmelCase     (    self    )			->   Optional[Any]:


        '''simple docstring'''


        lowercase_			:       Optional[int]									=			NllbTokenizer(__UpperCamelCase  ,keep_accents=__UpperCamelCase    )

        lowercase_			:       Dict									=			tokenizer.tokenize('This is a test'    )
        self.assertListEqual(__UpperCamelCase  ,['▁This', '▁is', '▁a', '▁t', 'est']    )

        self.assertListEqual(
            tokenizer.convert_tokens_to_ids(__UpperCamelCase    )  ,[value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]  ,)

        lowercase_			:       Tuple									=			tokenizer.tokenize('I was born in 92000, and this is falsé.'    )
        self.assertListEqual(
            __UpperCamelCase  ,[
                SPIECE_UNDERLINE + 'I',
                SPIECE_UNDERLINE + 'was',
                SPIECE_UNDERLINE + 'b',
                'or',
                'n',
                SPIECE_UNDERLINE + 'in',
                SPIECE_UNDERLINE + '',
                '9',
                '2',
                '0',
                '0',
                '0',
                ',',
                SPIECE_UNDERLINE + 'and',
                SPIECE_UNDERLINE + 'this',
                SPIECE_UNDERLINE + 'is',
                SPIECE_UNDERLINE + 'f',
                'al',
                's',
                'é',
                '.',
            ]  ,)
        lowercase_			:       Optional[int]									=			tokenizer.convert_tokens_to_ids(__UpperCamelCase    )
        self.assertListEqual(
            __UpperCamelCase  ,[
                value + tokenizer.fairseq_offset
                for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
            ]  ,)

        lowercase_			:       Optional[Any]									=			tokenizer.convert_ids_to_tokens(__UpperCamelCase    )
        self.assertListEqual(
            __UpperCamelCase  ,[
                SPIECE_UNDERLINE + 'I',
                SPIECE_UNDERLINE + 'was',
                SPIECE_UNDERLINE + 'b',
                'or',
                'n',
                SPIECE_UNDERLINE + 'in',
                SPIECE_UNDERLINE + '',
                '<unk>',
                '2',
                '0',
                '0',
                '0',
                ',',
                SPIECE_UNDERLINE + 'and',
                SPIECE_UNDERLINE + 'this',
                SPIECE_UNDERLINE + 'is',
                SPIECE_UNDERLINE + 'f',
                'al',
                's',
                '<unk>',
                '.',
            ]  ,)
   def     _UpperCAmelCase     (    self    )			->   Union[str, Any]:


        '''simple docstring'''


        lowercase_			:       Optional[int]									=			(self.rust_tokenizer_class, 'hf-internal-testing/tiny-random-nllb', {})
        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
             with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
                  lowercase_			:       Tuple									=			self.rust_tokenizer_class.from_pretrained(__UpperCamelCase  ,**__UpperCamelCase    )
                  lowercase_			:       int									=			self.tokenizer_class.from_pretrained(__UpperCamelCase  ,**__UpperCamelCase    )

                  lowercase_			:       Union[str, Any]									=			tempfile.mkdtemp()

                  lowercase_			:       Union[str, Any]									=			tokenizer_r.save_pretrained(__UpperCamelCase    )
                  lowercase_			:       Optional[int]									=			tokenizer_p.save_pretrained(__UpperCamelCase    )

                  # Checks it save with the same files + the tokenizer.json file for the fast one
                  self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files    )    )
                  lowercase_			:       int									=			tuple(f for f in tokenizer_r_files if 'tokenizer.json' not in f    )
                  self.assertSequenceEqual(__UpperCamelCase  ,__UpperCamelCase    )

                  # Checks everything loads correctly in the same way
                  lowercase_			:       Optional[int]									=			tokenizer_r.from_pretrained(__UpperCamelCase    )
                  lowercase_			:       List[str]									=			tokenizer_p.from_pretrained(__UpperCamelCase    )

                  # Check special tokens are set accordingly on Rust and Python
                  for key in tokenizer_pp.special_tokens_map:
                       self.assertTrue(hasattr(__UpperCamelCase  ,__UpperCamelCase    )    )

                  shutil.rmtree(__UpperCamelCase    )

                  # Save tokenizer rust, legacy_format=True
                  lowercase_			:       Any									=			tempfile.mkdtemp()

                  lowercase_			:       Optional[int]									=			tokenizer_r.save_pretrained(__UpperCamelCase  ,legacy_format=__UpperCamelCase    )
                  lowercase_			:       Any									=			tokenizer_p.save_pretrained(__UpperCamelCase    )

                  # Checks it save with the same files
                  self.assertSequenceEqual(__UpperCamelCase  ,__UpperCamelCase    )

                  # Checks everything loads correctly in the same way
                  lowercase_			:       Any									=			tokenizer_r.from_pretrained(__UpperCamelCase    )
                  lowercase_			:       Union[str, Any]									=			tokenizer_p.from_pretrained(__UpperCamelCase    )

                  # Check special tokens are set accordingly on Rust and Python
                  for key in tokenizer_pp.special_tokens_map:
                       self.assertTrue(hasattr(__UpperCamelCase  ,__UpperCamelCase    )    )

                  shutil.rmtree(__UpperCamelCase    )

                  # Save tokenizer rust, legacy_format=False
                  lowercase_			:       Tuple									=			tempfile.mkdtemp()

                  lowercase_			:       Any									=			tokenizer_r.save_pretrained(__UpperCamelCase  ,legacy_format=__UpperCamelCase    )
                  lowercase_			:       str									=			tokenizer_p.save_pretrained(__UpperCamelCase    )

                  # Checks it saved the tokenizer.json file
                  self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files    )    )

                  # Checks everything loads correctly in the same way
                  lowercase_			:       Union[str, Any]									=			tokenizer_r.from_pretrained(__UpperCamelCase    )
                  lowercase_			:       Union[str, Any]									=			tokenizer_p.from_pretrained(__UpperCamelCase    )

                  # Check special tokens are set accordingly on Rust and Python
                  for key in tokenizer_pp.special_tokens_map:
                       self.assertTrue(hasattr(__UpperCamelCase  ,__UpperCamelCase    )    )

                  shutil.rmtree(__UpperCamelCase    )
   @require_torch
   def     _UpperCAmelCase     (    self    )			->   List[Any]:


        '''simple docstring'''


        if not self.test_seqaseq:
             return

        lowercase_			:       Optional[int]									=			self.get_tokenizers()
        for tokenizer in tokenizers:
             with self.subTest(f'''{tokenizer.__class__.__name__}'''    ):
                  # Longer text that will definitely require truncation.
                  lowercase_			:       Tuple									=			[
                      ' UN Chief Says There Is No Military Solution in Syria',
                      ' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for'
                      ' Syria is that \'there is no military solution\' to the nearly five-year conflict and more weapons'
                      ' will only worsen the violence and misery for millions of people.',
                  ]
                  lowercase_			:       List[Any]									=			[
                      'Şeful ONU declară că nu există o soluţie militară în Siria',
                      'Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al'
                      ' Rusiei pentru Siria este că "nu există o soluţie militară" la conflictul de aproape cinci ani şi'
                      ' că noi arme nu vor face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.',
                  ]
                  try:
                       lowercase_			:       int									=			tokenizer.prepare_seqaseq_batch(
                           src_texts=__UpperCamelCase  ,tgt_texts=__UpperCamelCase  ,max_length=3  ,max_target_length=10  ,return_tensors='pt'  ,src_lang='eng_Latn'  ,tgt_lang='ron_Latn'  ,)
                  except NotImplementedError:
                       return
                  self.assertEqual(batch.input_ids.shape[1]  ,3    )
                  self.assertEqual(batch.labels.shape[1]  ,10    )
                  # max_target_length will default to max_length if not specified
                  lowercase_			:       Dict									=			tokenizer.prepare_seqaseq_batch(
                      __UpperCamelCase  ,tgt_texts=__UpperCamelCase  ,max_length=3  ,return_tensors='pt'    )
                  self.assertEqual(batch.input_ids.shape[1]  ,3    )
                  self.assertEqual(batch.labels.shape[1]  ,3    )

                  lowercase_			:       List[Any]									=			tokenizer.prepare_seqaseq_batch(
                      src_texts=__UpperCamelCase  ,max_length=3  ,max_target_length=10  ,return_tensors='pt'    )
                  self.assertEqual(batch_encoder_only.input_ids.shape[1]  ,3    )
                  self.assertEqual(batch_encoder_only.attention_mask.shape[1]  ,3    )
                  self.assertNotIn('decoder_input_ids'  ,__UpperCamelCase    )
   @unittest.skip('Unfortunately way too slow to build a BPE with SentencePiece.'    )
   def     _UpperCAmelCase     (    self    )			->   List[str]:


        '''simple docstring'''


        pass







   def     _UpperCAmelCase     (    self    )			->   Dict:


        '''simple docstring'''


        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
             with self.subTest(f'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
                  lowercase_			:       Dict									=			[AddedToken('<special>'  ,lstrip=__UpperCamelCase    )]

                  lowercase_			:       Optional[Any]									=			self.rust_tokenizer_class.from_pretrained(
                      __UpperCamelCase  ,additional_special_tokens=__UpperCamelCase  ,**__UpperCamelCase    )
                  lowercase_			:       List[Any]									=			tokenizer_r.encode('Hey this is a <special> token'    )

                  lowercase_			:       Dict									=			tokenizer_r.encode('<special>'  ,add_special_tokens=__UpperCamelCase    )[0]

                  self.assertTrue(special_token_id in r_output    )

                  if self.test_slow_tokenizer:
                       lowercase_			:       Any									=			self.rust_tokenizer_class.from_pretrained(
                           __UpperCamelCase  ,additional_special_tokens=__UpperCamelCase  ,**__UpperCamelCase  ,)
                       lowercase_			:       Optional[int]									=			self.tokenizer_class.from_pretrained(
                           __UpperCamelCase  ,additional_special_tokens=__UpperCamelCase  ,**__UpperCamelCase    )

                       lowercase_			:       Tuple									=			tokenizer_p.encode('Hey this is a <special> token'    )

                       lowercase_			:       Any									=			tokenizer_cr.encode('Hey this is a <special> token'    )

                       self.assertEqual(__UpperCamelCase  ,__UpperCamelCase    )
                       self.assertEqual(__UpperCamelCase  ,__UpperCamelCase    )
                       self.assertTrue(special_token_id in p_output    )
                       self.assertTrue(special_token_id in cr_output    )







@require_torch
@require_sentencepiece
@require_tokenizers
class  UpperCamelCase	(    unittest.TestCase						):
   lowercase							=						'facebook/nllb-200-distilled-600M'
   lowercase							=						[
       ' UN Chief Says There Is No Military Solution in Syria',
       ' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for Syria is that "there is no military solution" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.',
   ]
   lowercase							=						[
       'Şeful ONU declară că nu există o soluţie militară în Siria',
       'Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei'
       ' pentru Siria este că "nu există o soluţie militară" la conflictul de aproape cinci ani şi că noi arme nu vor'
       ' face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.',
   ]
   lowercase							=						[
       2_5_6_0_4_7,
       1_6_2_9_7,
       1_3_4_4_0_8,
       8_1_6_5,
       2_4_8_0_6_6,
       1_4_7_3_4,
       9_5_0,
       1_1_3_5,
       1_0_5_7_2_1,
       3_5_7_3,
       8_3,
       2_7_3_5_2,
       1_0_8,
       4_9_4_8_6,
       2,
   ]
   @classmethod
   def     _UpperCAmelCase     (    cls    )			->   Tuple:


        '''simple docstring'''


        lowercase_			:       NllbTokenizer									=			NllbTokenizer.from_pretrained(
            cls.checkpoint_name  ,src_lang='eng_Latn'  ,tgt_lang='ron_Latn'    )
        lowercase_			:       Dict									=			1
        return cls
   def     _UpperCAmelCase     (    self    )			->   Dict:


        '''simple docstring'''


        self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Arab']  ,25_6001    )
        self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Latn']  ,25_6002    )
        self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['fra_Latn']  ,25_6057    )
   def     _UpperCAmelCase     (    self    )			->   Optional[Any]:


        '''simple docstring'''


        lowercase_			:       List[Any]									=			self.tokenizer.batch_encode_plus(self.src_text    ).input_ids[0]
        self.assertListEqual(self.expected_src_tokens  ,__UpperCamelCase    )
   def     _UpperCAmelCase     (    self    )			->   Union[str, Any]:


        '''simple docstring'''


        self.assertIn(__UpperCamelCase  ,self.tokenizer.all_special_ids    )
        # fmt: off
        lowercase_			:       Tuple									=			[RO_CODE, 4254, 9_8068, 11_2923, 3_9072, 3909, 713, 10_2767, 26, 1_7314, 3_5642, 1_4683, 3_3118, 2022, 6_6987, 2, 25_6047]
        # fmt: on

        lowercase_			:       Any									=			self.tokenizer.decode(__UpperCamelCase  ,skip_special_tokens=__UpperCamelCase    )
        lowercase_			:       List[str]									=			self.tokenizer.decode(generated_ids[1:]  ,skip_special_tokens=__UpperCamelCase    )
        self.assertEqual(__UpperCamelCase  ,__UpperCamelCase    )
        self.assertNotIn(self.tokenizer.eos_token  ,__UpperCamelCase    )
   def     _UpperCAmelCase     (    self    )			->   Union[str, Any]:


        '''simple docstring'''


        lowercase_			:       Union[str, Any]									=			['this is gunna be a long sentence ' * 20]
        assert isinstance(src_text[0]  ,__UpperCamelCase    )
        lowercase_			:       Tuple									=			10
        lowercase_			:       str									=			self.tokenizer(__UpperCamelCase  ,max_length=__UpperCamelCase  ,truncation=__UpperCamelCase    ).input_ids[0]
        self.assertEqual(ids[-1]  ,2    )
        self.assertEqual(ids[0]  ,__UpperCamelCase    )
        self.assertEqual(len(__UpperCamelCase    )  ,__UpperCamelCase    )
   def     _UpperCAmelCase     (    self    )			->   List[Any]:


        '''simple docstring'''


        self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['<mask>', 'ar_AR']    )  ,[25_6203, 3]    )
   def     _UpperCAmelCase     (    self    )			->   Union[str, Any]:


        '''simple docstring'''


        lowercase_			:       List[Any]									=			tempfile.mkdtemp()
        lowercase_			:       str									=			self.tokenizer.fairseq_tokens_to_ids
        self.tokenizer.save_pretrained(__UpperCamelCase    )
        lowercase_			:       Tuple									=			NllbTokenizer.from_pretrained(__UpperCamelCase    )
        self.assertDictEqual(new_tok.fairseq_tokens_to_ids  ,__UpperCamelCase    )
   @require_torch
   def     _UpperCAmelCase     (    self    )			->   int:


        '''simple docstring'''


        lowercase_			:       Any									=			self.tokenizer(
            self.src_text  ,text_target=self.tgt_text  ,padding=__UpperCamelCase  ,truncation=__UpperCamelCase  ,max_length=len(self.expected_src_tokens    )  ,return_tensors='pt'  ,)
        lowercase_			:       Optional[Any]									=			shift_tokens_right(
            batch['labels']  ,self.tokenizer.pad_token_id  ,self.tokenizer.lang_code_to_id['ron_Latn']    )

        self.assertIsInstance(__UpperCamelCase  ,__UpperCamelCase    )

        self.assertEqual((2, 15)  ,batch.input_ids.shape    )
        self.assertEqual((2, 15)  ,batch.attention_mask.shape    )
        lowercase_			:       Tuple									=			batch.input_ids.tolist()[0]
        self.assertListEqual(self.expected_src_tokens  ,__UpperCamelCase    )
        self.assertEqual(__UpperCamelCase  ,batch.decoder_input_ids[0, 0]    )  # EOS
        # Test that special tokens are reset
        self.assertEqual(self.tokenizer.prefix_tokens  ,[EN_CODE]    )
        self.assertEqual(self.tokenizer.suffix_tokens  ,[self.tokenizer.eos_token_id]    )
   def     _UpperCAmelCase     (    self    )			->   Optional[int]:


        '''simple docstring'''


        lowercase_			:       Tuple									=			self.tokenizer(self.src_text  ,padding=__UpperCamelCase  ,truncation=__UpperCamelCase  ,max_length=3  ,return_tensors='pt'    )
        lowercase_			:       Optional[Any]									=			self.tokenizer(
            text_target=self.tgt_text  ,padding=__UpperCamelCase  ,truncation=__UpperCamelCase  ,max_length=10  ,return_tensors='pt'    )
        lowercase_			:       Optional[int]									=			targets['input_ids']
        lowercase_			:       List[str]									=			shift_tokens_right(
            __UpperCamelCase  ,self.tokenizer.pad_token_id  ,decoder_start_token_id=self.tokenizer.lang_code_to_id[self.tokenizer.tgt_lang]  ,)

        self.assertEqual(batch.input_ids.shape[1]  ,3    )
        self.assertEqual(batch.decoder_input_ids.shape[1]  ,10    )
   @require_torch
   def     _UpperCAmelCase     (    self    )			->   Tuple:


        '''simple docstring'''


        lowercase_			:       List[Any]									=			self.tokenizer._build_translation_inputs(
            'A test'  ,return_tensors='pt'  ,src_lang='eng_Latn'  ,tgt_lang='fra_Latn'    )

        self.assertEqual(
            nested_simplify(__UpperCamelCase    )  ,{
                # A, test, EOS, en_XX
                'input_ids': [[25_6047, 70, 7356, 2]],
                'attention_mask': [[1, 1, 1, 1]],
                # ar_AR
                'forced_bos_token_id': 25_6057,
            }  ,)







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


        '''simple docstring'''


        lowercase_			:       Optional[int]									=			True
        lowercase_			:       Union[str, Any]									=			self.tokenizer(
            'UN Chief says there is no military solution in Syria'  ,src_lang='eng_Latn'  ,tgt_lang='fra_Latn'    )
        self.assertEqual(
            inputs.input_ids  ,[1_6297, 13_4408, 2_5653, 6370, 248, 254, 10_3929, 9_4995, 108, 4_9486, 2, 25_6047]    )

        lowercase_			:       List[str]									=			False
        lowercase_			:       Dict									=			self.tokenizer(
            'UN Chief says there is no military solution in Syria'  ,src_lang='eng_Latn'  ,tgt_lang='fra_Latn'    )
        self.assertEqual(
            inputs.input_ids  ,[25_6047, 1_6297, 13_4408, 2_5653, 6370, 248, 254, 10_3929, 9_4995, 108, 4_9486, 2]    )


"""simple docstring"""







import logging
import os
from logging import (
    CRITICAL,  # NOQA
    DEBUG,  # NOQA
    ERROR,  # NOQA
    FATAL,  # NOQA
    INFO,  # NOQA
    NOTSET,  # NOQA
    WARN,  # NOQA
    WARNING,  # NOQA
)
from typing import Optional

from tqdm import auto as tqdm_lib


__SCREAMING_SNAKE_CASE								={
    "debug": logging.DEBUG,
    "info": logging.INFO,
    "warning": logging.WARNING,
    "error": logging.ERROR,
    "critical": logging.CRITICAL,
}

__SCREAMING_SNAKE_CASE								=logging.WARNING



def     lowercase__( ):
     lowercase_			:       List[Any]									=			os.getenv('DATASETS_VERBOSITY'  ,    __SCREAMING_SNAKE_CASE   )
     if env_level_str:
          if env_level_str in log_levels:
               return log_levels[env_level_str]
          else:
               logging.getLogger().warning(
                   F'''Unknown option DATASETS_VERBOSITY={env_level_str}, '''
                   F'''has to be one of: { ", ".join(log_levels.keys()   ) }'''   )
     return _default_log_level



def     lowercase__( ):
     return __name__.split('.'   )[0]



def     lowercase__( ):
     return logging.getLogger(_get_library_name()   )



def     lowercase__( ):
     # Apply our default configuration to the library root logger.
     lowercase_			:       Optional[int]									=			_get_library_root_logger()
     library_root_logger.setLevel(_get_default_logging_level()   )



def     lowercase__( ):
     lowercase_			:       int									=			_get_library_root_logger()
     library_root_logger.setLevel(logging.NOTSET   )



def     lowercase__( __SCREAMING_SNAKE_CASE							:  Optional[str] = None   ):
     if name is None:
          lowercase_			:       Union[str, Any]									=			_get_library_name()
     return logging.getLogger(__SCREAMING_SNAKE_CASE   )



def     lowercase__( ):
     return _get_library_root_logger().getEffectiveLevel()



def     lowercase__( __SCREAMING_SNAKE_CASE							:  int   ):
     _get_library_root_logger().setLevel(__SCREAMING_SNAKE_CASE   )



def     lowercase__( ):
     return set_verbosity(__SCREAMING_SNAKE_CASE   )



def     lowercase__( ):
     return set_verbosity(__SCREAMING_SNAKE_CASE   )



def     lowercase__( ):
     return set_verbosity(__SCREAMING_SNAKE_CASE   )



def     lowercase__( ):
     return set_verbosity(__SCREAMING_SNAKE_CASE   )



def     lowercase__( ):
     lowercase_			:       Tuple									=			False



def     lowercase__( ):
     lowercase_			:       Any									=			True


# Configure the library root logger at the module level (singleton-like)
_configure_library_root_logger()







class  UpperCamelCase	:
   def __init__(    self  ,*__UpperCamelCase  ,**__UpperCamelCase    )			->   int:  # pylint: disable=unused-argument


        '''simple docstring'''


        lowercase_			:       Optional[Any]									=			args[0] if args else None
   def __iter__(    self    )			->   Union[str, Any]:


        '''simple docstring'''


        return iter(self._iterator    )
   def __getattr__(    self  ,__UpperCamelCase    )			->   List[Any]:


        '''simple docstring'''


        def empty_fn(*__UpperCamelCase  ,**__UpperCamelCase    ):  # pylint: disable=unused-argument
             return

        return empty_fn
   def __enter__(    self    )			->   Optional[int]:


        '''simple docstring'''


        return self







   def __exit__(    self  ,__UpperCamelCase  ,__UpperCamelCase  ,__UpperCamelCase    )			->   Dict:


        '''simple docstring'''


        return






__SCREAMING_SNAKE_CASE								=True







class  UpperCamelCase	:
   def __call__(    self  ,*__UpperCamelCase  ,__UpperCamelCase=False  ,**__UpperCamelCase    )			->   Tuple:


        '''simple docstring'''


        if _tqdm_active and not disable:
             return tqdm_lib.tqdm(*__UpperCamelCase  ,**__UpperCamelCase    )
        else:
             return EmptyTqdm(*__UpperCamelCase  ,**__UpperCamelCase    )
   def     _UpperCAmelCase     (    self  ,*__UpperCamelCase  ,**__UpperCamelCase    )			->   str:


        '''simple docstring'''


        lowercase_			:       Tuple									=			None
        if _tqdm_active:
             return tqdm_lib.tqdm.set_lock(*__UpperCamelCase  ,**__UpperCamelCase    )







   def     _UpperCAmelCase     (    self    )			->   Any:


        '''simple docstring'''


        if _tqdm_active:
             return tqdm_lib.tqdm.get_lock()






__SCREAMING_SNAKE_CASE								=_tqdm_cls()



def     lowercase__( ):
     global _tqdm_active
     return bool(_tqdm_active   )



def     lowercase__( ):
     global _tqdm_active
     lowercase_			:       Union[str, Any]									=			True







def     lowercase__( ):
     global _tqdm_active
     lowercase_			:       Optional[int]									=			False

