






'''simple docstring'''

from __future__ import annotations

import unittest

from transformers import MobileBertConfig, is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
     import tensorflow as tf

     from transformers import (
         TF_MODEL_FOR_PRETRAINING_MAPPING,
         TFMobileBertForMaskedLM,
         TFMobileBertForMultipleChoice,
         TFMobileBertForNextSentencePrediction,
         TFMobileBertForPreTraining,
         TFMobileBertForQuestionAnswering,
         TFMobileBertForSequenceClassification,
         TFMobileBertForTokenClassification,
         TFMobileBertModel,
     )






@require_tf
class     a_						(      __lowerCAmelCase     ,	__lowerCAmelCase     ,	unittest.TestCase    ):
  lowercase							=				(
      (
          TFMobileBertModel,
          TFMobileBertForMaskedLM,
          TFMobileBertForNextSentencePrediction,
          TFMobileBertForPreTraining,
          TFMobileBertForQuestionAnswering,
          TFMobileBertForSequenceClassification,
          TFMobileBertForTokenClassification,
          TFMobileBertForMultipleChoice,
      )
      if is_tf_available()
      else ()
  )
  lowercase							=				(
      {
          '''feature-extraction''': TFMobileBertModel,
          '''fill-mask''': TFMobileBertForMaskedLM,
          '''question-answering''': TFMobileBertForQuestionAnswering,
          '''text-classification''': TFMobileBertForSequenceClassification,
          '''token-classification''': TFMobileBertForTokenClassification,
          '''zero-shot''': TFMobileBertForSequenceClassification,
      }
      if is_tf_available()
      else {}
  )
  lowercase							=				False
  lowercase							=				False

  def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE=False				)  ->				int:



        """simple docstring"""






        UpperCamelCase      = super()._prepare_for_class(lowerCAmelCase_      ,		lowerCAmelCase_      ,		return_labels=lowerCAmelCase_				)

        if return_labels:
              if model_class in get_values(lowerCAmelCase_				):
                    UpperCamelCase      = tf.zeros(self.model_tester.batch_size      ,		dtype=tf.intaa				)

        return inputs_dict






  class     a_						(      __lowerCAmelCase    ):

    def __init__(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE=13      ,		_SCREAMING_SNAKE_CASE=7      ,		_SCREAMING_SNAKE_CASE=True      ,		_SCREAMING_SNAKE_CASE=True      ,		_SCREAMING_SNAKE_CASE=True      ,		_SCREAMING_SNAKE_CASE=True      ,		_SCREAMING_SNAKE_CASE=99      ,		_SCREAMING_SNAKE_CASE=32      ,		_SCREAMING_SNAKE_CASE=32      ,		_SCREAMING_SNAKE_CASE=2      ,		_SCREAMING_SNAKE_CASE=4      ,		_SCREAMING_SNAKE_CASE=37      ,		_SCREAMING_SNAKE_CASE="gelu"      ,		_SCREAMING_SNAKE_CASE=0.1      ,		_SCREAMING_SNAKE_CASE=0.1      ,		_SCREAMING_SNAKE_CASE=512      ,		_SCREAMING_SNAKE_CASE=16      ,		_SCREAMING_SNAKE_CASE=2      ,		_SCREAMING_SNAKE_CASE=0.0_2      ,		_SCREAMING_SNAKE_CASE=3      ,		_SCREAMING_SNAKE_CASE=4      ,		_SCREAMING_SNAKE_CASE=None      ,		)  ->				List[str]:



          """simple docstring"""






          UpperCamelCase      = parent
          UpperCamelCase      = batch_size
          UpperCamelCase      = seq_length
          UpperCamelCase      = is_training
          UpperCamelCase      = use_input_mask
          UpperCamelCase      = use_token_type_ids
          UpperCamelCase      = use_labels
          UpperCamelCase      = vocab_size
          UpperCamelCase      = hidden_size
          UpperCamelCase      = num_hidden_layers
          UpperCamelCase      = num_attention_heads
          UpperCamelCase      = intermediate_size
          UpperCamelCase      = hidden_act
          UpperCamelCase      = hidden_dropout_prob
          UpperCamelCase      = attention_probs_dropout_prob
          UpperCamelCase      = max_position_embeddings
          UpperCamelCase      = type_vocab_size
          UpperCamelCase      = type_sequence_label_size
          UpperCamelCase      = initializer_range
          UpperCamelCase      = num_labels
          UpperCamelCase      = num_choices
          UpperCamelCase      = scope
          UpperCamelCase      = embedding_size

    def   A__						(				self				)  ->				str:



          """simple docstring"""






          UpperCamelCase      = ids_tensor([self.batch_size, self.seq_length]      ,		self.vocab_size				)

          UpperCamelCase      = None
          if self.use_input_mask:
                UpperCamelCase      = random_attention_mask([self.batch_size, self.seq_length]				)

          UpperCamelCase      = None
          if self.use_token_type_ids:
                UpperCamelCase      = ids_tensor([self.batch_size, self.seq_length]      ,		self.type_vocab_size				)

          UpperCamelCase      = None
          UpperCamelCase      = None
          UpperCamelCase      = None
          if self.use_labels:
                UpperCamelCase      = ids_tensor([self.batch_size]      ,		self.type_sequence_label_size				)
                UpperCamelCase      = ids_tensor([self.batch_size, self.seq_length]      ,		self.num_labels				)
                UpperCamelCase      = ids_tensor([self.batch_size]      ,		self.num_choices				)

          UpperCamelCase      = MobileBertConfig(
              vocab_size=self.vocab_size      ,		hidden_size=self.hidden_size      ,		num_hidden_layers=self.num_hidden_layers      ,		num_attention_heads=self.num_attention_heads      ,		intermediate_size=self.intermediate_size      ,		hidden_act=self.hidden_act      ,		hidden_dropout_prob=self.hidden_dropout_prob      ,		attention_probs_dropout_prob=self.attention_probs_dropout_prob      ,		max_position_embeddings=self.max_position_embeddings      ,		type_vocab_size=self.type_vocab_size      ,		initializer_range=self.initializer_range      ,		embedding_size=self.embedding_size      ,		)

          return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

    def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				str:



          """simple docstring"""






          UpperCamelCase      = TFMobileBertModel(config=lowerCAmelCase_				)
          UpperCamelCase      = {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
          UpperCamelCase      = model(lowerCAmelCase_				)

          UpperCamelCase      = [input_ids, input_mask]
          UpperCamelCase      = model(lowerCAmelCase_				)

          UpperCamelCase      = model(lowerCAmelCase_				)

          self.parent.assertEqual(
              result.last_hidden_state.shape      ,		(self.batch_size, self.seq_length, self.hidden_size)				)
          self.parent.assertEqual(result.pooler_output.shape      ,		(self.batch_size, self.hidden_size)				)

    def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				List[str]:



          """simple docstring"""






          UpperCamelCase      = TFMobileBertForMaskedLM(config=lowerCAmelCase_				)
          UpperCamelCase      = {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
          UpperCamelCase      = model(lowerCAmelCase_				)
          self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.seq_length, self.vocab_size)				)

    def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				Optional[int]:



          """simple docstring"""






          UpperCamelCase      = TFMobileBertForNextSentencePrediction(config=lowerCAmelCase_				)
          UpperCamelCase      = {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
          UpperCamelCase      = model(lowerCAmelCase_				)
          self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, 2)				)

    def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				Dict:



          """simple docstring"""






          UpperCamelCase      = TFMobileBertForPreTraining(config=lowerCAmelCase_				)
          UpperCamelCase      = {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
          UpperCamelCase      = model(lowerCAmelCase_				)
          self.parent.assertEqual(
              result.prediction_logits.shape      ,		(self.batch_size, self.seq_length, self.vocab_size)				)
          self.parent.assertEqual(result.seq_relationship_logits.shape      ,		(self.batch_size, 2)				)

    def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				Union[str, Any]:



          """simple docstring"""






          UpperCamelCase      = self.num_labels
          UpperCamelCase      = TFMobileBertForSequenceClassification(config=lowerCAmelCase_				)
          UpperCamelCase      = {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
          UpperCamelCase      = model(lowerCAmelCase_				)
          self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.num_labels)				)

    def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				Any:



          """simple docstring"""






          UpperCamelCase      = self.num_choices
          UpperCamelCase      = TFMobileBertForMultipleChoice(config=lowerCAmelCase_				)
          UpperCamelCase      = tf.tile(tf.expand_dims(lowerCAmelCase_      ,		1				)      ,		(1, self.num_choices, 1)				)
          UpperCamelCase      = tf.tile(tf.expand_dims(lowerCAmelCase_      ,		1				)      ,		(1, self.num_choices, 1)				)
          UpperCamelCase      = tf.tile(tf.expand_dims(lowerCAmelCase_      ,		1				)      ,		(1, self.num_choices, 1)				)
          UpperCamelCase      = {
              """input_ids""": multiple_choice_inputs_ids,
              """attention_mask""": multiple_choice_input_mask,
              """token_type_ids""": multiple_choice_token_type_ids,
          }
          UpperCamelCase      = model(lowerCAmelCase_				)
          self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.num_choices)				)

    def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				Optional[int]:



          """simple docstring"""






          UpperCamelCase      = self.num_labels
          UpperCamelCase      = TFMobileBertForTokenClassification(config=lowerCAmelCase_				)
          UpperCamelCase      = {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
          UpperCamelCase      = model(lowerCAmelCase_				)
          self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.seq_length, self.num_labels)				)

    def   A__						(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)  ->				Tuple:



          """simple docstring"""






          UpperCamelCase      = TFMobileBertForQuestionAnswering(config=lowerCAmelCase_				)
          UpperCamelCase      = {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
          UpperCamelCase      = model(lowerCAmelCase_				)
          self.parent.assertEqual(result.start_logits.shape      ,		(self.batch_size, self.seq_length)				)
          self.parent.assertEqual(result.end_logits.shape      ,		(self.batch_size, self.seq_length)				)


    def   A__						(				self				)  ->				List[str]:



          """simple docstring"""






          UpperCamelCase      = self.prepare_config_and_inputs()
          (
              (
              UpperCamelCase  
          )  ,(
              UpperCamelCase  
          )  ,(
              UpperCamelCase  
          )  ,(
              UpperCamelCase  
          )  ,(
              UpperCamelCase  
          )  ,(
              UpperCamelCase  
          )  ,(
              UpperCamelCase  
          )  ,  
          )      = config_and_inputs
          UpperCamelCase      = {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
          return config, inputs_dict


  def   A__						(				self				)  ->				Any:



        """simple docstring"""






        UpperCamelCase      = TFMobileBertModelTest.TFMobileBertModelTester(self				)
        UpperCamelCase      = ConfigTester(self      ,		config_class=lowerCAmelCase_      ,		hidden_size=37				)

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



        """simple docstring"""






        self.config_tester.run_common_tests()

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



        """simple docstring"""






        UpperCamelCase      = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mobilebert_model(*lowerCAmelCase_				)

  def   A__						(				self				)  ->				int:



        """simple docstring"""






        UpperCamelCase      = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mobilebert_for_masked_lm(*lowerCAmelCase_				)

  def   A__						(				self				)  ->				int:



        """simple docstring"""






        UpperCamelCase      = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mobilebert_for_multiple_choice(*lowerCAmelCase_				)

  def   A__						(				self				)  ->				List[str]:



        """simple docstring"""






        UpperCamelCase      = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*lowerCAmelCase_				)

  def   A__						(				self				)  ->				str:



        """simple docstring"""






        UpperCamelCase      = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mobilebert_for_pretraining(*lowerCAmelCase_				)

  def   A__						(				self				)  ->				str:



        """simple docstring"""






        UpperCamelCase      = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mobilebert_for_question_answering(*lowerCAmelCase_				)

  def   A__						(				self				)  ->				Tuple:



        """simple docstring"""






        UpperCamelCase      = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mobilebert_for_sequence_classification(*lowerCAmelCase_				)

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



        """simple docstring"""






        UpperCamelCase      = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mobilebert_for_token_classification(*lowerCAmelCase_				)


  @slow
  def   A__						(				self				)  ->				List[Any]:



        """simple docstring"""






        for model_name in ["google/mobilebert-uncased"]:
              UpperCamelCase      = TFMobileBertModel.from_pretrained(lowerCAmelCase_				)
              self.assertIsNotNone(lowerCAmelCase_				)






@require_tf
class     a_						(      unittest.TestCase    ):

  @slow
  def   A__						(				self				)  ->				List[Any]:



        """simple docstring"""






        UpperCamelCase      = TFMobileBertForPreTraining.from_pretrained("""google/mobilebert-uncased"""				)
        UpperCamelCase      = tf.constant([[0, 1, 2, 3, 4, 5]]				)
        UpperCamelCase      = model(lowerCAmelCase_				)[0]

        UpperCamelCase      = [1, 6, 30522]
        self.assertEqual(output.shape      ,		lowerCAmelCase_				)

        UpperCamelCase      = tf.constant(
            [
                [
                    [-4.5_9_1_9_5_4_7, -9.2_4_8_2_9_5, -9.6_4_5_2_5_6],
                    [-6.7_3_0_6_1_7_5, -6.4_4_0_2_8_4, -6.6_0_5_2_8_3_7],
                    [-7.2_7_4_3_5_0_6, -6.7_8_4_7_9_1_5, -6.0_2_4_6_7_3],
                ]
            ]				)
        tf.debugging.assert_near(output[:, :3, :3]      ,		lowerCAmelCase_      ,		atol=1e-4				)








'''simple docstring'''

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

import huggingface_hub.utils as hf_hub_utils
from tqdm import auto as tqdm_lib


SCREAMING_SNAKE_CASE__     =       threading.Lock()
SCREAMING_SNAKE_CASE__     =       None

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

SCREAMING_SNAKE_CASE__     =       logging.WARNING

SCREAMING_SNAKE_CASE__     =       True







def    lowercase__			(				)->			Optional[int]:
      UpperCamelCase      = os.getenv("""TRANSFORMERS_VERBOSITY"""		,						__UpperCamelCase   )
      if env_level_str:
            if env_level_str in log_levels:
                  return log_levels[env_level_str]
            else:
                  logging.getLogger().warning(
                      F"Unknown option TRANSFORMERS_VERBOSITY={env_level_str}, "
                      F"has to be one of: { ', '.join(log_levels.keys()   ) }"   )
      return _default_log_level







def    lowercase__			(				)->			str:
      return __name__.split("""."""   )[0]







def    lowercase__			(				)->			logging.Logger:
      return logging.getLogger(_get_library_name()   )







def    lowercase__			(				)->			None:
      global _default_handler

      with _lock:
            if _default_handler:
                  # This library has already configured the library root logger.
                  return
            UpperCamelCase      = logging.StreamHandler()  # Set sys.stderr as stream.
            UpperCamelCase      = sys.stderr.flush

            # Apply our default configuration to the library root logger.
            UpperCamelCase      = _get_library_root_logger()
            library_root_logger.addHandler(_default_handler   )
            library_root_logger.setLevel(_get_default_logging_level()   )
            UpperCamelCase      = False







def    lowercase__			(				)->			None:
      global _default_handler

      with _lock:
            if not _default_handler:
                  return

            UpperCamelCase      = _get_library_root_logger()
            library_root_logger.removeHandler(_default_handler   )
            library_root_logger.setLevel(logging.NOTSET   )
            UpperCamelCase      = None







def    lowercase__			(				)->			Tuple:
      return log_levels







def    lowercase__			(				__UpperCamelCase = None   )->			logging.Logger:

      if name is None:
            UpperCamelCase      = _get_library_name()

      _configure_library_root_logger()
      return logging.getLogger(__UpperCamelCase   )







def    lowercase__			(				)->			int:
      _configure_library_root_logger()
      return _get_library_root_logger().getEffectiveLevel()







def    lowercase__			(				__UpperCamelCase   )->			None:
      _configure_library_root_logger()
      _get_library_root_logger().setLevel(__UpperCamelCase   )







def    lowercase__			(				)->			Tuple:
      return set_verbosity(__UpperCamelCase   )







def    lowercase__			(				)->			Union[str, Any]:
      return set_verbosity(__UpperCamelCase   )







def    lowercase__			(				)->			Optional[int]:
      return set_verbosity(__UpperCamelCase   )







def    lowercase__			(				)->			Tuple:
      return set_verbosity(__UpperCamelCase   )







def    lowercase__			(				)->			None:
      _configure_library_root_logger()

      assert _default_handler is not None
      _get_library_root_logger().removeHandler(_default_handler   )







def    lowercase__			(				)->			None:
      _configure_library_root_logger()

      assert _default_handler is not None
      _get_library_root_logger().addHandler(_default_handler   )







def    lowercase__			(				__UpperCamelCase   )->			None:
      _configure_library_root_logger()

      assert handler is not None
      _get_library_root_logger().addHandler(__UpperCamelCase   )







def    lowercase__			(				__UpperCamelCase   )->			None:
      _configure_library_root_logger()

      assert handler is not None and handler not in _get_library_root_logger().handlers
      _get_library_root_logger().removeHandler(__UpperCamelCase   )







def    lowercase__			(				)->			None:
      _configure_library_root_logger()
      UpperCamelCase      = False







def    lowercase__			(				)->			None:
      _configure_library_root_logger()
      UpperCamelCase      = True







def    lowercase__			(				)->			None:
      UpperCamelCase      = _get_library_root_logger().handlers

      for handler in handlers:
            UpperCamelCase      = logging.Formatter("""[%(levelname)s|%(filename)s:%(lineno)s] %(asctime)s >> %(message)s"""   )
            handler.setFormatter(__UpperCamelCase   )







def    lowercase__			(				)->			None:
      UpperCamelCase      = _get_library_root_logger().handlers

      for handler in handlers:
            handler.setFormatter(__UpperCamelCase   )







def    lowercase__			(				self		,						*__UpperCamelCase		,						**__UpperCamelCase   )->			Tuple:
      UpperCamelCase      = os.getenv("""TRANSFORMERS_NO_ADVISORY_WARNINGS"""		,						__UpperCamelCase   )
      if no_advisory_warnings:
            return
      self.warning(*__UpperCamelCase		,						**__UpperCamelCase   )


SCREAMING_SNAKE_CASE__     =       warning_advice







@functools.lru_cache(__UpperCamelCase   )
def    lowercase__			(				self		,						*__UpperCamelCase		,						**__UpperCamelCase   )->			Optional[Any]:
      self.warning(*__UpperCamelCase		,						**__UpperCamelCase   )


SCREAMING_SNAKE_CASE__     =       warning_once






class     a_						:

  def __init__(				self      ,		*_SCREAMING_SNAKE_CASE      ,		**_SCREAMING_SNAKE_CASE				)  ->				Optional[int]:  # pylint: disable=unused-argument



        """simple docstring"""






        UpperCamelCase      = args[0] if args else None

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



        """simple docstring"""






        return iter(self._iterator				)

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



        """simple docstring"""






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

        return empty_fn

  def __enter__(				self				)  ->				Dict:



        """simple docstring"""






        return self


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



        """simple docstring"""






        return






class     a_						:

  def __call__(				self      ,		*_SCREAMING_SNAKE_CASE      ,		**_SCREAMING_SNAKE_CASE				)  ->				str:



        """simple docstring"""






        if _tqdm_active:
              return tqdm_lib.tqdm(*_SCREAMING_SNAKE_CASE      ,		**_SCREAMING_SNAKE_CASE				)
        else:
              return EmptyTqdm(*_SCREAMING_SNAKE_CASE      ,		**_SCREAMING_SNAKE_CASE				)

  def   A__						(				self      ,		*_SCREAMING_SNAKE_CASE      ,		**_SCREAMING_SNAKE_CASE				)  ->				Optional[Any]:



        """simple docstring"""






        UpperCamelCase      = None
        if _tqdm_active:
              return tqdm_lib.tqdm.set_lock(*_SCREAMING_SNAKE_CASE      ,		**_SCREAMING_SNAKE_CASE				)


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



        """simple docstring"""






        if _tqdm_active:
              return tqdm_lib.tqdm.get_lock()


SCREAMING_SNAKE_CASE__     =       _tqdm_cls()







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







def    lowercase__			(				)->			Optional[Any]:
      global _tqdm_active
      UpperCamelCase      = True
      hf_hub_utils.enable_progress_bars()







def    lowercase__			(				)->			str:
      global _tqdm_active
      UpperCamelCase      = False
      hf_hub_utils.disable_progress_bars()
