






'''simple docstring'''

import unittest

from transformers import AutoTokenizer, FalconConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch

     from transformers import (
         FalconForCausalLM,
         FalconForQuestionAnswering,
         FalconForSequenceClassification,
         FalconForTokenClassification,
         FalconModel,
     )






class     a_						:

  def __init__(				self      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE=3      ,		_SCREAMING_SNAKE_CASE=7      ,		_SCREAMING_SNAKE_CASE=True      ,		_SCREAMING_SNAKE_CASE=True      ,		_SCREAMING_SNAKE_CASE=False      ,		_SCREAMING_SNAKE_CASE=True      ,		_SCREAMING_SNAKE_CASE=99      ,		_SCREAMING_SNAKE_CASE=32      ,		_SCREAMING_SNAKE_CASE=5      ,		_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      ,		)  ->				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

  def   A__						(				self				)  ->				Any:



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

        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      = self.get_config()

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

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



        """simple docstring"""






        return FalconConfig(
            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      ,		is_decoder=_SCREAMING_SNAKE_CASE      ,		initializer_range=self.initializer_range      ,		pad_token_id=1      ,		new_decoder_architecture=_SCREAMING_SNAKE_CASE      ,		)

  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      = FalconModel(config=_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()
        UpperCamelCase      = model(_SCREAMING_SNAKE_CASE      ,		attention_mask=_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = model(_SCREAMING_SNAKE_CASE				)
        self.parent.assertEqual(result.last_hidden_state.shape      ,		(self.batch_size, self.seq_length, 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      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		)  ->				List[str]:



        """simple docstring"""






        UpperCamelCase      = True
        UpperCamelCase      = FalconModel(_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()
        UpperCamelCase      = model(
            _SCREAMING_SNAKE_CASE      ,		attention_mask=_SCREAMING_SNAKE_CASE      ,		encoder_hidden_states=_SCREAMING_SNAKE_CASE      ,		encoder_attention_mask=_SCREAMING_SNAKE_CASE      ,		)
        UpperCamelCase      = model(
            _SCREAMING_SNAKE_CASE      ,		attention_mask=_SCREAMING_SNAKE_CASE      ,		encoder_hidden_states=_SCREAMING_SNAKE_CASE      ,		)
        UpperCamelCase      = model(_SCREAMING_SNAKE_CASE      ,		attention_mask=_SCREAMING_SNAKE_CASE				)
        self.parent.assertEqual(result.last_hidden_state.shape      ,		(self.batch_size, self.seq_length, 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      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		)  ->				Tuple:



        """simple docstring"""






        UpperCamelCase      = FalconForCausalLM(config=_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()
        UpperCamelCase      = model(_SCREAMING_SNAKE_CASE      ,		attention_mask=_SCREAMING_SNAKE_CASE      ,		labels=_SCREAMING_SNAKE_CASE				)
        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      ,		_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		)  ->				int:



        """simple docstring"""






        UpperCamelCase      = True
        UpperCamelCase      = True
        UpperCamelCase      = FalconForCausalLM(config=_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()

        # first forward pass
        UpperCamelCase      = model(
            _SCREAMING_SNAKE_CASE      ,		attention_mask=_SCREAMING_SNAKE_CASE      ,		encoder_hidden_states=_SCREAMING_SNAKE_CASE      ,		encoder_attention_mask=_SCREAMING_SNAKE_CASE      ,		use_cache=_SCREAMING_SNAKE_CASE      ,		)
        UpperCamelCase      = outputs.past_key_values

        # create hypothetical multiple next token and extent to next_input_ids
        UpperCamelCase      = ids_tensor((self.batch_size, 3)      ,		config.vocab_size				)
        UpperCamelCase      = ids_tensor((self.batch_size, 3)      ,		vocab_size=2				)

        # append to next input_ids and
        UpperCamelCase      = torch.cat([input_ids, next_tokens]      ,		dim=-1				)
        UpperCamelCase      = torch.cat([input_mask, next_mask]      ,		dim=-1				)

        UpperCamelCase      = model(
            _SCREAMING_SNAKE_CASE      ,		attention_mask=_SCREAMING_SNAKE_CASE      ,		encoder_hidden_states=_SCREAMING_SNAKE_CASE      ,		encoder_attention_mask=_SCREAMING_SNAKE_CASE      ,		output_hidden_states=_SCREAMING_SNAKE_CASE      ,		)["""hidden_states"""][0]
        UpperCamelCase      = model(
            _SCREAMING_SNAKE_CASE      ,		attention_mask=_SCREAMING_SNAKE_CASE      ,		encoder_hidden_states=_SCREAMING_SNAKE_CASE      ,		encoder_attention_mask=_SCREAMING_SNAKE_CASE      ,		past_key_values=_SCREAMING_SNAKE_CASE      ,		output_hidden_states=_SCREAMING_SNAKE_CASE      ,		)["""hidden_states"""][0]

        # select random slice
        UpperCamelCase      = ids_tensor((1,)      ,		output_from_past.shape[-1]				).item()
        UpperCamelCase      = output_from_no_past[:, -3:, random_slice_idx].detach()
        UpperCamelCase      = output_from_past[:, :, random_slice_idx].detach()

        self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]				)

        # test that outputs are equal for slice
        self.parent.assertTrue(torch.allclose(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE      ,		atol=1e-3				)				)


  def   A__						(				self				)  ->				str:



        """simple docstring"""






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






@require_torch
class     a_						(      lowerCamelCase     ,	lowerCamelCase     ,	lowerCamelCase     ,	unittest.TestCase    ):
  lowercase							=				(
      (
          FalconModel,
          FalconForCausalLM,
          FalconForSequenceClassification,
          FalconForTokenClassification,
          FalconForQuestionAnswering,
      )
      if is_torch_available()
      else ()
  )
  lowercase							=				(FalconForCausalLM,) if is_torch_available() else ()
  lowercase							=				(
      {
          """feature-extraction""": FalconModel,
          """text-classification""": FalconForSequenceClassification,
          """text-generation""": FalconForCausalLM,
          """question-answering""": FalconForQuestionAnswering,
          """token-classification""": FalconForTokenClassification,
          """zero-shot""": FalconForSequenceClassification,
      }
      if is_torch_available()
      else {}
  )
  lowercase							=				False
  lowercase							=				False

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



        """simple docstring"""






        UpperCamelCase      = FalconModelTester(self				)
        UpperCamelCase      = ConfigTester(self      ,		config_class=_SCREAMING_SNAKE_CASE      ,		hidden_size=37				)

  def   A__						(				self				)  ->				Tuple:



        """simple docstring"""






        self.config_tester.run_common_tests()

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



        """simple docstring"""






        UpperCamelCase      = self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE				)

  def   A__						(				self				)  ->				str:



        """simple docstring"""






        UpperCamelCase  ,*UpperCamelCase      = self.model_tester.prepare_config_and_inputs()
        for alibi in [True, False]:
              UpperCamelCase      = alibi
              self.model_tester.create_and_check_model(_SCREAMING_SNAKE_CASE      ,		*_SCREAMING_SNAKE_CASE				)

  def   A__						(				self				)  ->				Dict:



        """simple docstring"""






        UpperCamelCase  ,UpperCamelCase      = self.model_tester.prepare_config_and_inputs_for_common()
        UpperCamelCase      = 3
        UpperCamelCase      = input_dict["""input_ids"""]
        UpperCamelCase      = input_ids.ne(1				).to(_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = ids_tensor([self.model_tester.batch_size]      ,		self.model_tester.type_sequence_label_size				)
        UpperCamelCase      = FalconForSequenceClassification(_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()
        UpperCamelCase      = model(_SCREAMING_SNAKE_CASE      ,		attention_mask=_SCREAMING_SNAKE_CASE      ,		labels=_SCREAMING_SNAKE_CASE				)
        self.assertEqual(result.logits.shape      ,		(self.model_tester.batch_size, self.model_tester.num_labels)				)

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



        """simple docstring"""






        UpperCamelCase  ,UpperCamelCase      = self.model_tester.prepare_config_and_inputs_for_common()
        UpperCamelCase      = 3
        UpperCamelCase      = """single_label_classification"""
        UpperCamelCase      = input_dict["""input_ids"""]
        UpperCamelCase      = input_ids.ne(1				).to(_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = ids_tensor([self.model_tester.batch_size]      ,		self.model_tester.type_sequence_label_size				)
        UpperCamelCase      = FalconForSequenceClassification(_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()
        UpperCamelCase      = model(_SCREAMING_SNAKE_CASE      ,		attention_mask=_SCREAMING_SNAKE_CASE      ,		labels=_SCREAMING_SNAKE_CASE				)
        self.assertEqual(result.logits.shape      ,		(self.model_tester.batch_size, self.model_tester.num_labels)				)

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



        """simple docstring"""






        UpperCamelCase  ,UpperCamelCase      = self.model_tester.prepare_config_and_inputs_for_common()
        UpperCamelCase      = input_dict["""input_ids"""]
        UpperCamelCase      = FalconForCausalLM(_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()
        UpperCamelCase      = model(_SCREAMING_SNAKE_CASE      ,		use_cache=_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = input_ids.shape[0]
        UpperCamelCase      = model._convert_to_rw_cache(result.past_key_values				)
        UpperCamelCase      = model._convert_cache_to_standard_format(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)
        for layer in range(len(_SCREAMING_SNAKE_CASE				)				):
              for tensor_idx in range(2				):
                    self.assertTrue(rw_cache[layer][tensor_idx].ndim == 3				)
                    self.assertTrue(result.past_key_values[layer][tensor_idx].ndim == 4				)
                    self.assertTrue(
                        torch.all(result.past_key_values[layer][tensor_idx] == standard_cache[layer][tensor_idx]				)				)

  def   A__						(				self				)  ->				Dict:



        """simple docstring"""






        UpperCamelCase  ,UpperCamelCase      = self.model_tester.prepare_config_and_inputs_for_common()
        UpperCamelCase      = 3
        UpperCamelCase      = """multi_label_classification"""
        UpperCamelCase      = input_dict["""input_ids"""]
        UpperCamelCase      = input_ids.ne(1				).to(_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = ids_tensor(
            [self.model_tester.batch_size, config.num_labels]      ,		self.model_tester.type_sequence_label_size				).to(torch.float				)
        UpperCamelCase      = FalconForSequenceClassification(_SCREAMING_SNAKE_CASE				)
        model.to(_SCREAMING_SNAKE_CASE				)
        model.eval()
        UpperCamelCase      = model(_SCREAMING_SNAKE_CASE      ,		attention_mask=_SCREAMING_SNAKE_CASE      ,		labels=_SCREAMING_SNAKE_CASE				)
        self.assertEqual(result.logits.shape      ,		(self.model_tester.batch_size, self.model_tester.num_labels)				)


  def   A__						(				self				)  ->				Any:



        """simple docstring"""






        for model_class in self.all_generative_model_classes:
              UpperCamelCase  ,UpperCamelCase      = self.model_tester.prepare_config_and_inputs_for_common()

              # If it doesn't support cache, pass the test
              if not hasattr(_SCREAMING_SNAKE_CASE      ,		"""use_cache"""				):
                    return

              UpperCamelCase      = model_class(_SCREAMING_SNAKE_CASE				).to(_SCREAMING_SNAKE_CASE				)
              if "use_cache" not in inputs:
                    UpperCamelCase      = True
              UpperCamelCase      = model(**_SCREAMING_SNAKE_CASE				)

              # If "past_key_values" is not returned, pass the test (e.g. RWKV uses a different cache name and format)
              if "past_key_values" not in outputs:
                    return

              UpperCamelCase      = (
                  getattr(_SCREAMING_SNAKE_CASE      ,		"""decoder_layers"""      ,		_SCREAMING_SNAKE_CASE				)
                  or getattr(_SCREAMING_SNAKE_CASE      ,		"""num_decoder_layers"""      ,		_SCREAMING_SNAKE_CASE				)
                  or config.num_hidden_layers
              )
              UpperCamelCase      = getattr(_SCREAMING_SNAKE_CASE      ,		"""num_kv_heads"""      ,		config.num_attention_heads				)
              UpperCamelCase      = getattr(_SCREAMING_SNAKE_CASE      ,		"""d_model"""      ,		config.hidden_size				)
              UpperCamelCase      = embed_dim // num_attention_heads

              UpperCamelCase      = outputs["""past_key_values"""]
              self.assertEqual(len(_SCREAMING_SNAKE_CASE				)      ,		_SCREAMING_SNAKE_CASE				)

              UpperCamelCase  ,UpperCamelCase      = inputs["""input_ids"""].shape
              for i in range(_SCREAMING_SNAKE_CASE				):
                    if config.new_decoder_architecture:
                          UpperCamelCase      = config.num_attention_heads
                    elif config.multi_query:
                          UpperCamelCase      = 1
                    self.assertEqual(len(past_kv[0]				)      ,		2				)  # K V for the decoder = 2
                    self.assertEqual(
                        past_kv[i][0].shape      ,		(batch_size, num_attention_heads, seq_length, per_head_embed_dim)				)
                    self.assertEqual(
                        past_kv[i][1].shape      ,		(batch_size, num_attention_heads, seq_length, per_head_embed_dim)				)






@require_torch
class     a_						(      unittest.TestCase    ):

  @slow
  def   A__						(				self				)  ->				Tuple:



        """simple docstring"""






        UpperCamelCase      = AutoTokenizer.from_pretrained("""Rocketknight1/falcon-rw-1b"""				)
        UpperCamelCase      = FalconForCausalLM.from_pretrained("""Rocketknight1/falcon-rw-1b"""				)
        model.eval()
        model.to(_SCREAMING_SNAKE_CASE				)
        UpperCamelCase      = tokenizer("""My favorite food is"""      ,		return_tensors="""pt"""				).to(_SCREAMING_SNAKE_CASE				)

        UpperCamelCase      = (
            """My favorite food is pizza. I love it so much that I have a pizza party every year for my birthday."""
        )

        UpperCamelCase      = model.generate(**_SCREAMING_SNAKE_CASE      ,		do_sample=_SCREAMING_SNAKE_CASE      ,		max_new_tokens=19				)
        UpperCamelCase      = tokenizer.batch_decode(_SCREAMING_SNAKE_CASE				)[0]

        self.assertEqual(_SCREAMING_SNAKE_CASE      ,		_SCREAMING_SNAKE_CASE				)

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



        """simple docstring"""






        for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
              UpperCamelCase      = AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE				)
              UpperCamelCase      = FalconForCausalLM.from_pretrained(_SCREAMING_SNAKE_CASE				)
              model.eval()
              model.to(_SCREAMING_SNAKE_CASE				)
              UpperCamelCase      = tokenizer("""My favorite food is"""      ,		return_tensors="""pt"""				).to(_SCREAMING_SNAKE_CASE				)

              # We just test that these run without errors - the models are randomly initialized
              # and so the actual text outputs will be garbage
              model.generate(**_SCREAMING_SNAKE_CASE      ,		do_sample=_SCREAMING_SNAKE_CASE      ,		max_new_tokens=4				)
              model.generate(**_SCREAMING_SNAKE_CASE      ,		do_sample=_SCREAMING_SNAKE_CASE      ,		max_new_tokens=4				)
              model.generate(**_SCREAMING_SNAKE_CASE      ,		num_beams=2      ,		max_new_tokens=4				)


  @slow
  def   A__						(				self				)  ->				str:



        """simple docstring"""






        with torch.no_grad():
              for repo in [
                  "Rocketknight1/falcon-rw-1b",
                  "Rocketknight1/tiny-random-falcon-7b",
                  "Rocketknight1/tiny-random-falcon-40b",
              ]:
                    UpperCamelCase      = AutoTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE				)
                    UpperCamelCase      = FalconForCausalLM.from_pretrained(_SCREAMING_SNAKE_CASE				)
                    model.eval()
                    model.to(device=_SCREAMING_SNAKE_CASE				)
                    UpperCamelCase      = tokenizer("""My favorite food is"""      ,		return_tensors="""pt"""				).to(_SCREAMING_SNAKE_CASE				)

                    # Test results are the same with and without cache
                    UpperCamelCase      = model.generate(**_SCREAMING_SNAKE_CASE      ,		do_sample=_SCREAMING_SNAKE_CASE      ,		max_new_tokens=20      ,		use_cache=_SCREAMING_SNAKE_CASE				)
                    UpperCamelCase      = model.generate(**_SCREAMING_SNAKE_CASE      ,		do_sample=_SCREAMING_SNAKE_CASE      ,		max_new_tokens=20      ,		use_cache=_SCREAMING_SNAKE_CASE				)
                    self.assertTrue((outputs_cache - outputs_no_cache).sum().item() == 0				)








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