
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      _UpperCAmelCase				:
    def __init__(    self						,    snake_case_						,    snake_case_=3						,    snake_case_=7						,    snake_case_=True						,    snake_case_=True						,    snake_case_=False						,    snake_case_=True						,    snake_case_=99						,    snake_case_=32						,    snake_case_=5						,    snake_case_=4						,    snake_case_=37						,    snake_case_="gelu"						,    snake_case_=0.1						,    snake_case_=0.1						,    snake_case_=5_12						,    snake_case_=16						,    snake_case_=2						,    snake_case_=0.02						,    snake_case_=3						,    snake_case_=4						,    snake_case_=None						,    ):
      _snake_case     :						List[Any]						=   parent
      _snake_case     :						Dict						=   batch_size
      _snake_case     :						int						=   seq_length
      _snake_case     :						int						=   is_training
      _snake_case     :						Tuple						=   use_input_mask
      _snake_case     :						str						=   use_token_type_ids
      _snake_case     :						Optional[int]						=   use_labels
      _snake_case     :						Tuple						=   vocab_size
      _snake_case     :						Optional[int]						=   hidden_size
      _snake_case     :						Optional[int]						=   num_hidden_layers
      _snake_case     :						Dict						=   num_attention_heads
      _snake_case     :						Dict						=   intermediate_size
      _snake_case     :						Any						=   hidden_act
      _snake_case     :						List[str]						=   hidden_dropout_prob
      _snake_case     :						List[Any]						=   attention_probs_dropout_prob
      _snake_case     :						Optional[int]						=   max_position_embeddings
      _snake_case     :						Union[str, Any]						=   type_vocab_size
      _snake_case     :						List[str]						=   type_sequence_label_size
      _snake_case     :						Union[str, Any]						=   initializer_range
      _snake_case     :						List[str]						=   num_labels
      _snake_case     :						Union[str, Any]						=   num_choices
      _snake_case     :						Union[str, Any]						=   scope
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						List[str]						=   ids_tensor([self.batch_size, self.seq_length]						,    self.vocab_size     )

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

      _snake_case     :						Tuple						=   None

      _snake_case     :						Any						=   None
      _snake_case     :						Any						=   None
      _snake_case     :						int						=   None
      if self.use_labels:
        _snake_case     :						str						=   ids_tensor([self.batch_size]						,    self.type_sequence_label_size     )
        _snake_case     :						Optional[int]						=   ids_tensor([self.batch_size, self.seq_length]						,    self.num_labels     )
        _snake_case     :						Tuple						=   ids_tensor([self.batch_size]						,    self.num_choices     )

      _snake_case     :						int						=   self.get_config()

      return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
    def 					lowerCamelCase__	(    self     ):
      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=snake_case_						,    initializer_range=self.initializer_range						,    pad_token_id=1						,    new_decoder_architecture=snake_case_						,    )
    def 					lowerCamelCase__	(    self						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_     ):
      _snake_case     :						int						=   FalconModel(config=snake_case_     )
      model.to(snake_case_     )
      model.eval()
      _snake_case     :						Dict						=   model(snake_case_						,    attention_mask=snake_case_     )
      _snake_case     :						List[str]						=   model(snake_case_     )
      self.parent.assertEqual(result.last_hidden_state.shape						,    (self.batch_size, self.seq_length, self.hidden_size)     )
    def 					lowerCamelCase__	(    self						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    ):
      _snake_case     :						Optional[int]						=   True
      _snake_case     :						Optional[int]						=   FalconModel(snake_case_     )
      model.to(snake_case_     )
      model.eval()
      _snake_case     :						Tuple						=   model(
          snake_case_						,    attention_mask=snake_case_						,    encoder_hidden_states=snake_case_						,    encoder_attention_mask=snake_case_						,    )
      _snake_case     :						Any						=   model(
          snake_case_						,    attention_mask=snake_case_						,    encoder_hidden_states=snake_case_						,    )
      _snake_case     :						Tuple						=   model(snake_case_						,    attention_mask=snake_case_     )
      self.parent.assertEqual(result.last_hidden_state.shape						,    (self.batch_size, self.seq_length, self.hidden_size)     )
    def 					lowerCamelCase__	(    self						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    ):
      _snake_case     :						Dict						=   FalconForCausalLM(config=snake_case_     )
      model.to(snake_case_     )
      model.eval()
      _snake_case     :						Dict						=   model(snake_case_						,    attention_mask=snake_case_						,    labels=snake_case_     )
      self.parent.assertEqual(result.logits.shape						,    (self.batch_size, self.seq_length, self.vocab_size)     )
    def 					lowerCamelCase__	(    self						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    ):
      _snake_case     :						Optional[Any]						=   True
      _snake_case     :						Dict						=   True
      _snake_case     :						List[str]						=   FalconForCausalLM(config=snake_case_     )
      model.to(snake_case_     )
      model.eval()

      # first forward pass
      _snake_case     :						int						=   model(
          snake_case_						,    attention_mask=snake_case_						,    encoder_hidden_states=snake_case_						,    encoder_attention_mask=snake_case_						,    use_cache=snake_case_						,    )
      _snake_case     :						List[Any]						=   outputs.past_key_values

      # create hypothetical multiple next token and extent to next_input_ids
      _snake_case     :						Union[str, Any]						=   ids_tensor((self.batch_size, 3)						,    config.vocab_size     )
      _snake_case     :						Union[str, Any]						=   ids_tensor((self.batch_size, 3)						,    vocab_size=2     )

      # append to next input_ids and
      _snake_case     :						Optional[int]						=   torch.cat([input_ids, next_tokens]						,    dim=-1     )
      _snake_case     :						List[Any]						=   torch.cat([input_mask, next_mask]						,    dim=-1     )

      _snake_case     :						Optional[int]						=   model(
          snake_case_						,    attention_mask=snake_case_						,    encoder_hidden_states=snake_case_						,    encoder_attention_mask=snake_case_						,    output_hidden_states=snake_case_						,    )["hidden_states"][0]
      _snake_case     :						Tuple						=   model(
          snake_case_						,    attention_mask=snake_case_						,    encoder_hidden_states=snake_case_						,    encoder_attention_mask=snake_case_						,    past_key_values=snake_case_						,    output_hidden_states=snake_case_						,    )["hidden_states"][0]

      # select random slice
      _snake_case     :						List[str]						=   ids_tensor((1,)						,    output_from_past.shape[-1]     ).item()
      _snake_case     :						Union[str, Any]						=   output_from_no_past[:, -3:, random_slice_idx].detach()
      _snake_case     :						Tuple						=   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(snake_case_						,    snake_case_						,    atol=1E-3     )     )


    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						List[str]						=   self.prepare_config_and_inputs()
      (
          _snake_case					
      )     :						Tuple						=   config_and_inputs
      _snake_case     :						Tuple						=   {"input_ids": input_ids, "attention_mask": input_mask}
      return config, inputs_dict






@require_torch
class      _UpperCAmelCase				(					_snake_case		,					_snake_case		,					_snake_case		,					unittest.TestCase):
    __lowercase							: str  =					(
        (
            FalconModel,
            FalconForCausalLM,
            FalconForSequenceClassification,
            FalconForTokenClassification,
            FalconForQuestionAnswering,
        )
        if is_torch_available()
        else ()
    )
    __lowercase							: Dict  =					(FalconForCausalLM,) if is_torch_available() else ()
    __lowercase							: str  =					(
        {
            """feature-extraction""": FalconModel,
            """text-classification""": FalconForSequenceClassification,
            """text-generation""": FalconForCausalLM,
            """question-answering""": FalconForQuestionAnswering,
            """token-classification""": FalconForTokenClassification,
            """zero-shot""": FalconForSequenceClassification,
        }
        if is_torch_available()
        else {}
    )
    __lowercase							: Optional[Any]  =					False
    __lowercase							: List[str]  =					False
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						str						=   FalconModelTester(self     )
      _snake_case     :						Optional[int]						=   ConfigTester(self						,    config_class=snake_case_						,    hidden_size=37     )
    def 					lowerCamelCase__	(    self     ):
      self.config_tester.run_common_tests()
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Union[str, Any]						=   self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*snake_case_     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Any						=   self.model_tester.prepare_config_and_inputs()
      for alibi in [True, False]:
        _snake_case     :						Optional[int]						=   alibi
        self.model_tester.create_and_check_model(snake_case_						,    *snake_case_     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Union[str, Any]						=   self.model_tester.prepare_config_and_inputs_for_common()
      _snake_case     :						Dict						=   3
      _snake_case     :						List[str]						=   input_dict["input_ids"]
      _snake_case     :						Any						=   input_ids.ne(1     ).to(snake_case_     )
      _snake_case     :						Dict						=   ids_tensor([self.model_tester.batch_size]						,    self.model_tester.type_sequence_label_size     )
      _snake_case     :						int						=   FalconForSequenceClassification(snake_case_     )
      model.to(snake_case_     )
      model.eval()
      _snake_case     :						Any						=   model(snake_case_						,    attention_mask=snake_case_						,    labels=snake_case_     )
      self.assertEqual(result.logits.shape						,    (self.model_tester.batch_size, self.model_tester.num_labels)     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						int						=   self.model_tester.prepare_config_and_inputs_for_common()
      _snake_case     :						Optional[Any]						=   3
      _snake_case     :						int						=   "single_label_classification"
      _snake_case     :						Any						=   input_dict["input_ids"]
      _snake_case     :						List[Any]						=   input_ids.ne(1     ).to(snake_case_     )
      _snake_case     :						Union[str, Any]						=   ids_tensor([self.model_tester.batch_size]						,    self.model_tester.type_sequence_label_size     )
      _snake_case     :						int						=   FalconForSequenceClassification(snake_case_     )
      model.to(snake_case_     )
      model.eval()
      _snake_case     :						Optional[Any]						=   model(snake_case_						,    attention_mask=snake_case_						,    labels=snake_case_     )
      self.assertEqual(result.logits.shape						,    (self.model_tester.batch_size, self.model_tester.num_labels)     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Union[str, Any]						=   self.model_tester.prepare_config_and_inputs_for_common()
      _snake_case     :						Optional[int]						=   input_dict["input_ids"]
      _snake_case     :						Optional[Any]						=   FalconForCausalLM(snake_case_     )
      model.to(snake_case_     )
      model.eval()
      _snake_case     :						str						=   model(snake_case_						,    use_cache=snake_case_     )
      _snake_case     :						Any						=   input_ids.shape[0]
      _snake_case     :						Union[str, Any]						=   model._convert_to_rw_cache(result.past_key_values     )
      _snake_case     :						Optional[Any]						=   model._convert_cache_to_standard_format(snake_case_						,    snake_case_     )
      for layer in range(len(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 					lowerCamelCase__	(    self     ):
      _snake_case     :						Any						=   self.model_tester.prepare_config_and_inputs_for_common()
      _snake_case     :						Tuple						=   3
      _snake_case     :						Optional[Any]						=   "multi_label_classification"
      _snake_case     :						Optional[int]						=   input_dict["input_ids"]
      _snake_case     :						Dict						=   input_ids.ne(1     ).to(snake_case_     )
      _snake_case     :						Optional[int]						=   ids_tensor(
          [self.model_tester.batch_size, config.num_labels]						,    self.model_tester.type_sequence_label_size     ).to(torch.float     )
      _snake_case     :						Any						=   FalconForSequenceClassification(snake_case_     )
      model.to(snake_case_     )
      model.eval()
      _snake_case     :						int						=   model(snake_case_						,    attention_mask=snake_case_						,    labels=snake_case_     )
      self.assertEqual(result.logits.shape						,    (self.model_tester.batch_size, self.model_tester.num_labels)     )


    def 					lowerCamelCase__	(    self     ):
      # Falcon can have different numbers of KV-heads than the number of query heads, so we need
      # to override this test to use the right head counts.
      for model_class in self.all_generative_model_classes:
        _snake_case     :						Optional[int]						=   self.model_tester.prepare_config_and_inputs_for_common()

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

        _snake_case     :						Dict						=   model_class(snake_case_     ).to(snake_case_     )
        if "use_cache" not in inputs:
          _snake_case     :						str						=   True
        _snake_case     :						Optional[Any]						=   model(**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

        _snake_case     :						str						=   (
            getattr(snake_case_						,    "decoder_layers"						,    snake_case_     )
            or getattr(snake_case_						,    "num_decoder_layers"						,    snake_case_     )
            or config.num_hidden_layers
        )
        _snake_case     :						Tuple						=   getattr(snake_case_						,    "num_kv_heads"						,    config.num_attention_heads     )
        _snake_case     :						Dict						=   getattr(snake_case_						,    "d_model"						,    config.hidden_size     )
        _snake_case     :						Dict						=   embed_dim // num_attention_heads

        _snake_case     :						str						=   outputs["past_key_values"]
        self.assertEqual(len(snake_case_     )						,    snake_case_     )

        _snake_case     :						str						=   inputs["input_ids"].shape
        for i in range(snake_case_     ):
          if config.new_decoder_architecture:
            _snake_case     :						Any						=   config.num_attention_heads
          elif config.multi_query:
            _snake_case     :						str						=   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      _UpperCAmelCase				(					unittest.TestCase):
    @slow
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						List[str]						=   AutoTokenizer.from_pretrained("Rocketknight1/falcon-rw-1b"     )
      _snake_case     :						List[str]						=   FalconForCausalLM.from_pretrained("Rocketknight1/falcon-rw-1b"     )
      model.eval()
      model.to(snake_case_     )
      _snake_case     :						str						=   tokenizer("My favorite food is"						,    return_tensors="pt"     ).to(snake_case_     )

      _snake_case     :						Union[str, Any]						=   (
          "My favorite food is pizza. I love it so much that I have a pizza party every year for my birthday."
      )

      _snake_case     :						Dict						=   model.generate(**snake_case_						,    do_sample=snake_case_						,    max_new_tokens=19     )
      _snake_case     :						List[str]						=   tokenizer.batch_decode(snake_case_     )[0]

      self.assertEqual(snake_case_						,    snake_case_     )
    @slow
    def 					lowerCamelCase__	(    self     ):
      # The big models are way too big for the CI, so we use tiny random models that resemble their
      # architectures but with much smaller and fewer layers
      for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
        _snake_case     :						Optional[int]						=   AutoTokenizer.from_pretrained(snake_case_     )
        _snake_case     :						List[Any]						=   FalconForCausalLM.from_pretrained(snake_case_     )
        model.eval()
        model.to(snake_case_     )
        _snake_case     :						List[str]						=   tokenizer("My favorite food is"						,    return_tensors="pt"     ).to(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(**snake_case_						,    do_sample=snake_case_						,    max_new_tokens=4     )
        model.generate(**snake_case_						,    do_sample=snake_case_						,    max_new_tokens=4     )
        model.generate(**snake_case_						,    num_beams=2						,    max_new_tokens=4     )


    @slow
    def 					lowerCamelCase__	(    self     ):
      # The big models are way too big for the CI, so we use tiny random models that resemble their
      # architectures but with much smaller and fewer layers
      with torch.no_grad():
        for repo in [
            "Rocketknight1/falcon-rw-1b",
            "Rocketknight1/tiny-random-falcon-7b",
            "Rocketknight1/tiny-random-falcon-40b",
        ]:
          _snake_case     :						Any						=   AutoTokenizer.from_pretrained(snake_case_     )
          _snake_case     :						Tuple						=   FalconForCausalLM.from_pretrained(snake_case_     )
          model.eval()
          model.to(device=snake_case_     )
          _snake_case     :						List[Any]						=   tokenizer("My favorite food is"						,    return_tensors="pt"     ).to(snake_case_     )

          # Test results are the same with and without cache
          _snake_case     :						Dict						=   model.generate(**snake_case_						,    do_sample=snake_case_						,    max_new_tokens=20						,    use_cache=snake_case_     )
          _snake_case     :						Optional[int]						=   model.generate(**snake_case_						,    do_sample=snake_case_						,    max_new_tokens=20						,    use_cache=snake_case_     )
          self.assertTrue((outputs_cache - outputs_no_cache).sum().item() == 0     )



"""simple docstring"""
from __future__ import annotations

from collections import namedtuple
def 				a__   (   a   :				float       ,     a   :				float       ,     a   :				float		):

  """simple docstring"""







  _snake_case     :						Optional[Any]						=   namedtuple("result"       ,     "name value"		)
  if (voltage, current, power).count(0		) != 1:
    raise ValueError("Only one argument must be 0"		)
  elif power < 0:
    raise ValueError(
        "Power cannot be negative in any electrical/electronics system"		)
  elif voltage == 0:
    return result("voltage"       ,     power / current		)
  elif current == 0:
    return result("current"       ,     power / voltage		)
  elif power == 0:
    return result("power"       ,     float(round(abs(voltage * current		)       ,     2		)		)		)
  else:
    raise ValueError("Exactly one argument must be 0"		)


if __name__ == "__main__":
    import doctest

    doctest.testmod()

