






from __future__ import annotations

import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, 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 numpy as np
       import tensorflow as tf

       from transformers import (
           TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
           FlaubertConfig,
           TFFlaubertForMultipleChoice,
           TFFlaubertForQuestionAnsweringSimple,
           TFFlaubertForSequenceClassification,
           TFFlaubertForTokenClassification,
           TFFlaubertModel,
           TFFlaubertWithLMHeadModel,
       )
class     a    :



      """simple docstring"""


      def __init__(      self					:			Optional[int]		,      __lowercase					:			Union[str, Any]		,      )							->      Any:
        __UpperCAmelCase							:	Optional[Any]           =  parent
        __UpperCAmelCase							:	List[Any]           =  13
        __UpperCAmelCase							:	Dict           =  7
        __UpperCAmelCase							:	int           =  True
        __UpperCAmelCase							:	Optional[int]           =  True
        __UpperCAmelCase							:	int           =  True
        __UpperCAmelCase							:	Optional[Any]           =  True
        __UpperCAmelCase							:	Tuple           =  True
        __UpperCAmelCase							:	Union[str, Any]           =  False
        __UpperCAmelCase							:	Any           =  False
        __UpperCAmelCase							:	Dict           =  False
        __UpperCAmelCase							:	str           =  2
        __UpperCAmelCase							:	Dict           =  99
        __UpperCAmelCase							:	Tuple           =  0
        __UpperCAmelCase							:	Union[str, Any]           =  32
        __UpperCAmelCase							:	Any           =  2
        __UpperCAmelCase							:	List[str]           =  4
        __UpperCAmelCase							:	Dict           =  0.1
        __UpperCAmelCase							:	Dict           =  0.1
        __UpperCAmelCase							:	List[Any]           =  512
        __UpperCAmelCase							:	List[str]           =  16
        __UpperCAmelCase							:	List[Any]           =  2
        __UpperCAmelCase							:	Dict           =  0.02
        __UpperCAmelCase							:	int           =  3
        __UpperCAmelCase							:	str           =  4
        __UpperCAmelCase							:	Any           =  """last"""
        __UpperCAmelCase							:	Tuple           =  True
        __UpperCAmelCase							:	Tuple           =  None
        __UpperCAmelCase							:	Tuple           =  0
      def 	UpperCAmelCase      (      self					:			Tuple					)							->      List[str]:
        __UpperCAmelCase							:	int           =  ids_tensor([self.batch_size, self.seq_length]		,      self.vocab_size					)
        __UpperCAmelCase							:	List[str]           =  random_attention_mask([self.batch_size, self.seq_length]		,      dtype=tf.floataa					)

        __UpperCAmelCase							:	Optional[Any]           =  None
        if self.use_input_lengths:
          __UpperCAmelCase							:	Any           =  (
              ids_tensor([self.batch_size]		,      vocab_size=2					) + self.seq_length - 2
          )  # small variation of seq_length

        __UpperCAmelCase							:	Dict           =  None
        if self.use_token_type_ids:
          __UpperCAmelCase							:	List[Any]           =  ids_tensor([self.batch_size, self.seq_length]		,      self.n_langs					)

        __UpperCAmelCase							:	str           =  None
        __UpperCAmelCase							:	Optional[Any]           =  None
        __UpperCAmelCase							:	List[str]           =  None
        if self.use_labels:
          __UpperCAmelCase							:	List[str]           =  ids_tensor([self.batch_size]		,      self.type_sequence_label_size					)
          __UpperCAmelCase							:	List[Any]           =  ids_tensor([self.batch_size, self.seq_length]		,      self.num_labels					)
          __UpperCAmelCase							:	List[str]           =  ids_tensor([self.batch_size]		,      2		,      dtype=tf.floataa					)
          __UpperCAmelCase							:	Any           =  ids_tensor([self.batch_size]		,      self.num_choices					)

        __UpperCAmelCase							:	Optional[Any]           =  FlaubertConfig(
            vocab_size=self.vocab_size		,      n_special=self.n_special		,      emb_dim=self.hidden_size		,      n_layers=self.num_hidden_layers		,      n_heads=self.num_attention_heads		,      dropout=self.hidden_dropout_prob		,      attention_dropout=self.attention_probs_dropout_prob		,      gelu_activation=self.gelu_activation		,      sinusoidal_embeddings=self.sinusoidal_embeddings		,      asm=self.asm		,      causal=self.causal		,      n_langs=self.n_langs		,      max_position_embeddings=self.max_position_embeddings		,      initializer_range=self.initializer_range		,      summary_type=self.summary_type		,      use_proj=self.use_proj		,      bos_token_id=self.bos_token_id		,      )

        return (
            config,
            input_ids,
            token_type_ids,
            input_lengths,
            sequence_labels,
            token_labels,
            is_impossible_labels,
            choice_labels,
            input_mask,
        )
      def 	UpperCAmelCase      (      self					:			List[str]		,      __lowercase					:			Tuple		,      __lowercase					:			Optional[Any]		,      __lowercase					:			str		,      __lowercase					:			Tuple		,      __lowercase					:			Any		,      __lowercase					:			List[str]		,      __lowercase					:			Optional[Any]		,      __lowercase					:			List[Any]		,      __lowercase					:			List[Any]		,      )							->      Optional[int]:
        __UpperCAmelCase							:	int           =  TFFlaubertModel(config=__lowercase					)
        __UpperCAmelCase							:	List[Any]           =  {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
        __UpperCAmelCase							:	Tuple           =  model(__lowercase					)

        __UpperCAmelCase							:	Any           =  [input_ids, input_mask]
        __UpperCAmelCase							:	Dict           =  model(__lowercase					)
        self.parent.assertEqual(result.last_hidden_state.shape		,      (self.batch_size, self.seq_length, self.hidden_size)					)
      def 	UpperCAmelCase      (      self					:			Tuple		,      __lowercase					:			List[str]		,      __lowercase					:			Tuple		,      __lowercase					:			Optional[Any]		,      __lowercase					:			int		,      __lowercase					:			List[str]		,      __lowercase					:			str		,      __lowercase					:			int		,      __lowercase					:			Optional[int]		,      __lowercase					:			Dict		,      )							->      Union[str, Any]:
        __UpperCAmelCase							:	str           =  TFFlaubertWithLMHeadModel(__lowercase					)

        __UpperCAmelCase							:	int           =  {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
        __UpperCAmelCase							:	int           =  model(__lowercase					)

        self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.seq_length, self.vocab_size)					)
      def 	UpperCAmelCase      (      self					:			Optional[Any]		,      __lowercase					:			Optional[Any]		,      __lowercase					:			List[Any]		,      __lowercase					:			str		,      __lowercase					:			Optional[int]		,      __lowercase					:			Dict		,      __lowercase					:			Optional[int]		,      __lowercase					:			Tuple		,      __lowercase					:			str		,      __lowercase					:			Any		,      )							->      str:
        __UpperCAmelCase							:	Optional[int]           =  TFFlaubertForQuestionAnsweringSimple(__lowercase					)

        __UpperCAmelCase							:	Tuple           =  {"""input_ids""": input_ids, """lengths""": input_lengths}

        __UpperCAmelCase							:	Any           =  model(__lowercase					)

        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 	UpperCAmelCase      (      self					:			Tuple		,      __lowercase					:			Union[str, Any]		,      __lowercase					:			str		,      __lowercase					:			Any		,      __lowercase					:			Dict		,      __lowercase					:			List[Any]		,      __lowercase					:			str		,      __lowercase					:			Any		,      __lowercase					:			Union[str, Any]		,      __lowercase					:			List[Any]		,      )							->      List[str]:
        __UpperCAmelCase							:	Optional[int]           =  TFFlaubertForSequenceClassification(__lowercase					)

        __UpperCAmelCase							:	Dict           =  {"""input_ids""": input_ids, """lengths""": input_lengths}

        __UpperCAmelCase							:	str           =  model(__lowercase					)

        self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.type_sequence_label_size)					)
      def 	UpperCAmelCase      (      self					:			List[str]		,      __lowercase					:			List[str]		,      __lowercase					:			Optional[Any]		,      __lowercase					:			str		,      __lowercase					:			Optional[Any]		,      __lowercase					:			int		,      __lowercase					:			Optional[int]		,      __lowercase					:			Tuple		,      __lowercase					:			Optional[int]		,      __lowercase					:			Tuple		,      )							->      List[Any]:
        __UpperCAmelCase							:	Any           =  self.num_labels
        __UpperCAmelCase							:	str           =  TFFlaubertForTokenClassification(config=__lowercase					)
        __UpperCAmelCase							:	int           =  {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
        __UpperCAmelCase							:	List[str]           =  model(__lowercase					)
        self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.seq_length, self.num_labels)					)
      def 	UpperCAmelCase      (      self					:			Optional[int]		,      __lowercase					:			List[Any]		,      __lowercase					:			Union[str, Any]		,      __lowercase					:			Union[str, Any]		,      __lowercase					:			Tuple		,      __lowercase					:			List[str]		,      __lowercase					:			Union[str, Any]		,      __lowercase					:			Any		,      __lowercase					:			Dict		,      __lowercase					:			Optional[int]		,      )							->      str:
        __UpperCAmelCase							:	Optional[int]           =  self.num_choices
        __UpperCAmelCase							:	Union[str, Any]           =  TFFlaubertForMultipleChoice(config=__lowercase					)
        __UpperCAmelCase							:	Dict           =  tf.tile(tf.expand_dims(__lowercase		,      1					)		,      (1, self.num_choices, 1)					)
        __UpperCAmelCase							:	int           =  tf.tile(tf.expand_dims(__lowercase		,      1					)		,      (1, self.num_choices, 1)					)
        __UpperCAmelCase							:	List[Any]           =  tf.tile(tf.expand_dims(__lowercase		,      1					)		,      (1, self.num_choices, 1)					)
        __UpperCAmelCase							:	Optional[int]           =  {
            """input_ids""": multiple_choice_inputs_ids,
            """attention_mask""": multiple_choice_input_mask,
            """token_type_ids""": multiple_choice_token_type_ids,
        }
        __UpperCAmelCase							:	str           =  model(__lowercase					)
        self.parent.assertEqual(result.logits.shape		,      (self.batch_size, self.num_choices)					)




      def 	UpperCAmelCase      (      self					:			int					)							->      Optional[Any]:
        __UpperCAmelCase							:	Tuple           =  self.prepare_config_and_inputs()
        (
            (
            __UpperCAmelCase
        )      , (
            __UpperCAmelCase
        )      , (
            __UpperCAmelCase
        )      , (
            __UpperCAmelCase
        )      , (
            __UpperCAmelCase
        )      , (
            __UpperCAmelCase
        )      , (
            __UpperCAmelCase
        )      , (
            __UpperCAmelCase
        )      , (
            __UpperCAmelCase
        )      , 
        )							:	str           =  config_and_inputs
        __UpperCAmelCase							:	Union[str, Any]           =  {
            """input_ids""": input_ids,
            """token_type_ids""": token_type_ids,
            """langs""": token_type_ids,
            """lengths""": input_lengths,
        }
        return config, inputs_dict


@require_tf
class     a    ( lowercase__							,       lowercase__							,       unittest.TestCase   ):



      """simple docstring"""


      a  : Dict							       =	(
          (
              TFFlaubertModel,
              TFFlaubertWithLMHeadModel,
              TFFlaubertForSequenceClassification,
              TFFlaubertForQuestionAnsweringSimple,
              TFFlaubertForTokenClassification,
              TFFlaubertForMultipleChoice,
          )
          if is_tf_available()
          else ()
      )
      a  : Tuple							       =	(
          (TFFlaubertWithLMHeadModel,) if is_tf_available() else ()
      )  # TODO (PVP): Check other models whether language generation is also applicable
      a  : List[Any]							       =	(
          {
              'feature-extraction': TFFlaubertModel,
              'fill-mask': TFFlaubertWithLMHeadModel,
              'question-answering': TFFlaubertForQuestionAnsweringSimple,
              'text-classification': TFFlaubertForSequenceClassification,
              'token-classification': TFFlaubertForTokenClassification,
              'zero-shot': TFFlaubertForSequenceClassification,
          }
          if is_tf_available()
          else {}
      )
      a  : int							       =	False
      a  : List[Any]							       =	False
      def 	UpperCAmelCase      (      self					:			str		,      __lowercase					:			List[Any]		,      __lowercase					:			Optional[int]		,      __lowercase					:			Optional[int]		,      __lowercase					:			Union[str, Any]		,      __lowercase					:			List[Any]					)							->      List[str]:
        if (
            pipeline_test_casse_name == "QAPipelineTests"
            and tokenizer_name is not None
            and not tokenizer_name.endswith("""Fast"""					)
        ):
          # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
          # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
          # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
          return True

        return False
      def 	UpperCAmelCase      (      self					:			Any					)							->      List[str]:
        __UpperCAmelCase							:	Dict           =  TFFlaubertModelTester(self					)
        __UpperCAmelCase							:	Union[str, Any]           =  ConfigTester(self		,      config_class=__lowercase		,      emb_dim=37					)
      def 	UpperCAmelCase      (      self					:			Any					)							->      List[Any]:
        self.config_tester.run_common_tests()
      def 	UpperCAmelCase      (      self					:			List[Any]					)							->      Dict:
        __UpperCAmelCase							:	Optional[Any]           =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_flaubert_model(*__lowercase					)
      def 	UpperCAmelCase      (      self					:			List[Any]					)							->      str:
        __UpperCAmelCase							:	Optional[Any]           =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_flaubert_lm_head(*__lowercase					)
      def 	UpperCAmelCase      (      self					:			Union[str, Any]					)							->      Optional[Any]:
        __UpperCAmelCase							:	Dict           =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_flaubert_qa(*__lowercase					)
      def 	UpperCAmelCase      (      self					:			int					)							->      Union[str, Any]:
        __UpperCAmelCase							:	Any           =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_flaubert_sequence_classif(*__lowercase					)
      def 	UpperCAmelCase      (      self					:			List[str]					)							->      Any:
        __UpperCAmelCase							:	Optional[Any]           =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_flaubert_for_token_classification(*__lowercase					)
      def 	UpperCAmelCase      (      self					:			Union[str, Any]					)							->      List[Any]:
        __UpperCAmelCase							:	List[str]           =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_flaubert_for_multiple_choice(*__lowercase					)




      @slow
      def 	UpperCAmelCase      (      self					:			Tuple					)							->      str:
        for model_name in TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          __UpperCAmelCase							:	int           =  TFFlaubertModel.from_pretrained(__lowercase					)
          self.assertIsNotNone(__lowercase					)


@require_tf
@require_sentencepiece
@require_tokenizers
class     a    ( unittest.TestCase   ):



      """simple docstring"""


      @slow
      def 	UpperCAmelCase      (      self					:			Union[str, Any]					)							->      Dict:
        __UpperCAmelCase							:	Union[str, Any]           =  TFFlaubertModel.from_pretrained("""jplu/tf-flaubert-small-cased"""					)

        __UpperCAmelCase							:	List[Any]           =  tf.convert_to_tensor(
            [[0, 158, 735, 2592, 1424, 6727, 82, 1]]		,      dtype=tf.intaa		,      )  # "J'aime flaubert !"

        __UpperCAmelCase							:	Optional[Any]           =  model(__lowercase					)[0]
        __UpperCAmelCase							:	str           =  tf.TensorShape((1, 8, 512)					)
        self.assertEqual(output.shape		,      __lowercase					)
        # compare the actual values for a slice.
        __UpperCAmelCase							:	Union[str, Any]           =  tf.convert_to_tensor(
            [
                [
                    [-1.8_768_773, -1.566_555, 0.27_072_418],
                    [-1.6_920_038, -0.5_873_505, 1.9_329_599],
                    [-2.9_563_985, -1.6_993_835, 1.7_972_052],
                ]
            ]		,      dtype=tf.floataa		,      )

        self.assertTrue(np.allclose(output[:, :3, :3].numpy()		,      expected_slice.numpy()		,      atol=1e-4					)					)










import copy
from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Audio, Features, Value
from .base import TaskTemplate
@dataclass(frozen=lowercase__   )
class     a    ( lowercase__   ):



      """simple docstring"""


      a  : str							       =	field(default='automatic-speech-recognition'							,       metadata={'include_in_asdict_even_if_is_default': True}   )
      a  : ClassVar[Features]							       =	Features({'audio': Audio()}   )
      a  : ClassVar[Features]							       =	Features({'transcription': Value('string'   )}   )
      a  : str							       =	"audio"
      a  : str							       =	"transcription"
      def 	UpperCAmelCase      (      self					:			Optional[Any]		,      __lowercase					:			Optional[int]					)							->      str:
        if self.audio_column not in features:
          raise ValueError(f"""Column {self.audio_column} is not present in features."""					)
        if not isinstance(features[self.audio_column]		,      __lowercase					):
          raise ValueError(f"""Column {self.audio_column} is not an Audio type."""					)
        __UpperCAmelCase							:	int           =  copy.deepcopy(self					)
        __UpperCAmelCase							:	str           =  self.input_schema.copy()
        __UpperCAmelCase							:	List[str]           =  features[self.audio_column]
        __UpperCAmelCase							:	Optional[Any]           =  input_schema
        return task_template




      @property
      def 	UpperCAmelCase      (      self					:			Union[str, Any]					)							->      Dict[str, str]:
        return {self.audio_column: "audio", self.transcription_column: "transcription"}


