'''simple docstring'''




from __future__ import annotations

import random

# Maximum size of the population.  Bigger could be faster but is more memory expensive.
__UpperCAmelCase					=2_0_0
# Number of elements selected in every generation of evolution. The selection takes
# place from best to worst of that generation and must be smaller than N_POPULATION.
__UpperCAmelCase					=5_0
# Probability that an element of a generation can mutate, changing one of its genes.
# This will guarantee that all genes will be used during evolution.
__UpperCAmelCase					=0.4
# Just a seed to improve randomness required by the algorithm.
random.seed(random.randint(0, 1_0_0_0))






def __lowerCAmelCase					(				UpperCamelCase__							,    UpperCamelCase__							)      ->       Union[str, Any]:
    __lowerCamelCase            =    len([g for position, g in enumerate(snake_case__							) if g == main_target[position]]							)
    return (item, float(snake_case__							))






def __lowerCAmelCase					(				UpperCamelCase__							,    UpperCamelCase__							)      ->       Tuple:
    __lowerCamelCase            =    random.randint(0							,    len(snake_case__							) - 1							)
    __lowerCamelCase            =    parent_a[:random_slice] + parent_a[random_slice:]
    __lowerCamelCase            =    parent_a[:random_slice] + parent_a[random_slice:]
    return (child_a, child_a)






def __lowerCAmelCase					(				UpperCamelCase__							,    UpperCamelCase__							)      ->       int:
    __lowerCamelCase            =    list(snake_case__							)
    if random.uniform(0							,    1							) < MUTATION_PROBABILITY:
        __lowerCamelCase            =    random.choice(snake_case__							)
    return "".join(snake_case__							)






def __lowerCAmelCase					(				UpperCamelCase__							,    UpperCamelCase__							,    UpperCamelCase__							,    )      ->       Tuple:
    __lowerCamelCase            =    []
    # Generate more children proportionally to the fitness score.
    __lowerCamelCase            =    int(parent_a[1] * 1_00							) + 1
    __lowerCamelCase            =    10 if child_n >= 10 else child_n
    for _ in range(snake_case__							):
        __lowerCamelCase            =    population_score[random.randint(0							,    snake_case__							)][0]

        __lowerCamelCase      ,    __lowerCamelCase            =    crossover(parent_a[0]							,    snake_case__							)
        # Append new string to the population list.
        pop.append(mutate(snake_case__							,    snake_case__							)							)
        pop.append(mutate(snake_case__							,    snake_case__							)							)
    return pop






def __lowerCAmelCase					(				UpperCamelCase__							,    UpperCamelCase__							,    UpperCamelCase__ = True							)      ->       Optional[int]:


    if N_POPULATION < N_SELECTED:
        __lowerCamelCase            =    f"""{N_POPULATION} must be bigger than {N_SELECTED}"""
        raise ValueError(snake_case__							)
    # Verify that the target contains no genes besides the ones inside genes variable.
    __lowerCamelCase            =    sorted({c for c in target if c not in genes}							)
    if not_in_genes_list:
        __lowerCamelCase            =    f"""{not_in_genes_list} is not in genes list, evolution cannot converge"""
        raise ValueError(snake_case__							)

    # Generate random starting population.
    __lowerCamelCase            =    []
    for _ in range(snake_case__							):
        population.append(''''''.join([random.choice(snake_case__							) for i in range(len(snake_case__							)							)]							)							)

    # Just some logs to know what the algorithms is doing.
    __lowerCamelCase      ,    __lowerCamelCase            =    0, 0

    # This loop will end when we find a perfect match for our target.
    while True:
        generation += 1
        total_population += len(snake_case__							)

        # Random population created. Now it's time to evaluate.

        # Adding a bit of concurrency can make everything faster,
        #
        # import concurrent.futures
        # population_score: list[tuple[str, float]] = []
        # with concurrent.futures.ThreadPoolExecutor(
        #                                   max_workers=NUM_WORKERS) as executor:
        #     futures = {executor.submit(evaluate, item) for item in population}
        #     concurrent.futures.wait(futures)
        #     population_score = [item.result() for item in futures]
        #
        # but with a simple algorithm like this, it will probably be slower.
        # We just need to call evaluate for every item inside the population.
        __lowerCamelCase            =    [evaluate(snake_case__							,    snake_case__							) for item in population]

        # Check if there is a matching evolution.
        __lowerCamelCase            =    sorted(snake_case__							,    key=lambda UpperCamelCase__							: x[1]							,    reverse=snake_case__							)
        if population_score[0][0] == target:
            return (generation, total_population, population_score[0][0])

        # Print the best result every 10 generation.
        # Just to know that the algorithm is working.
        if debug and generation % 10 == 0:
            print(
                f"""\nGeneration: {generation}"""
                f"""\nTotal Population:{total_population}"""
                f"""\nBest score: {population_score[0][1]}"""
                f"""\nBest string: {population_score[0][0]}"""							)

        # Flush the old population, keeping some of the best evolutions.
        # Keeping this avoid regression of evolution.
        __lowerCamelCase            =    population[: int(N_POPULATION / 3							)]
        population.clear()
        population.extend(snake_case__							)
        # Normalize population score to be between 0 and 1.
        __lowerCamelCase            =    [
            (item, score / len(snake_case__							)) for item, score in population_score
        ]

        # This is selection
        for i in range(snake_case__							):
            population.extend(select(population_score[int(snake_case__							)]							,    snake_case__							,    snake_case__							)							)
            # Check if the population has already reached the maximum value and if so,
            # break the cycle.  If this check is disabled, the algorithm will take
            # forever to compute large strings, but will also calculate small strings in
            # a far fewer generations.
            if len(snake_case__							) > N_POPULATION:
                break


if __name__ == "__main__":
  __UpperCAmelCase					=(
      "This is a genetic algorithm to evaluate, combine, evolve, and mutate a string!"
  )
  __UpperCAmelCase					=list(
      " ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklm"
      "nopqrstuvwxyz.,;!?+-*#@^'èéòà€ù=)(&%$£/\\"
  )
  __UpperCAmelCase					=basic(target_str, genes_list)
  print(
      f'\nGeneration: {generation}\nTotal Population: {population}\nTarget: {target}'
  )



"""simple docstring"""




from __future__ import annotations

import unittest

from transformers import FunnelConfig, is_tf_available
from transformers.testing_utils import require_tf

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 (
						    TFFunnelBaseModel,
						    TFFunnelForMaskedLM,
						    TFFunnelForMultipleChoice,
						    TFFunnelForPreTraining,
						    TFFunnelForQuestionAnswering,
						    TFFunnelForSequenceClassification,
						    TFFunnelForTokenClassification,
						    TFFunnelModel,
						)





class  lowerCamelCase    :

			def __init__(       self					:    str     ,					__UpperCAmelCase					:    Optional[Any]     ,					__UpperCAmelCase					:    Union[str, Any]=1_3     ,					__UpperCAmelCase					:    Union[str, Any]=7     ,					__UpperCAmelCase					:    List[str]=True     ,					__UpperCAmelCase					:    Tuple=True     ,					__UpperCAmelCase					:    Any=True     ,					__UpperCAmelCase					:    Dict=True     ,					__UpperCAmelCase					:    Union[str, Any]=9_9     ,					__UpperCAmelCase					:    str=[1, 1, 2]     ,					__UpperCAmelCase					:    str=1     ,					__UpperCAmelCase					:    Dict=3_2     ,					__UpperCAmelCase					:    Optional[int]=4     ,					__UpperCAmelCase					:    str=8     ,					__UpperCAmelCase					:    List[Any]=3_7     ,					__UpperCAmelCase					:    Union[str, Any]="gelu_new"     ,					__UpperCAmelCase					:    List[Any]=0.1     ,					__UpperCAmelCase					:    str=0.1     ,					__UpperCAmelCase					:    Any=0.0     ,					__UpperCAmelCase					:    str=5_1_2     ,					__UpperCAmelCase					:    Optional[Any]=3     ,					__UpperCAmelCase					:    List[str]=0.02     ,					__UpperCAmelCase					:    Tuple=3     ,					__UpperCAmelCase					:    str=4     ,					__UpperCAmelCase					:    Optional[Any]=None     ,					__UpperCAmelCase					:    int=False     ,					) ->     List[Any]:
						SCREAMING_SNAKE_CASE__										=   parent
						SCREAMING_SNAKE_CASE__										=   batch_size
						SCREAMING_SNAKE_CASE__										=   seq_length
						SCREAMING_SNAKE_CASE__										=   is_training
						SCREAMING_SNAKE_CASE__										=   use_input_mask
						SCREAMING_SNAKE_CASE__										=   use_token_type_ids
						SCREAMING_SNAKE_CASE__										=   use_labels
						SCREAMING_SNAKE_CASE__										=   vocab_size
						SCREAMING_SNAKE_CASE__										=   block_sizes
						SCREAMING_SNAKE_CASE__										=   num_decoder_layers
						SCREAMING_SNAKE_CASE__										=   d_model
						SCREAMING_SNAKE_CASE__										=   n_head
						SCREAMING_SNAKE_CASE__										=   d_head
						SCREAMING_SNAKE_CASE__										=   d_inner
						SCREAMING_SNAKE_CASE__										=   hidden_act
						SCREAMING_SNAKE_CASE__										=   hidden_dropout
						SCREAMING_SNAKE_CASE__										=   attention_dropout
						SCREAMING_SNAKE_CASE__										=   activation_dropout
						SCREAMING_SNAKE_CASE__										=   max_position_embeddings
						SCREAMING_SNAKE_CASE__										=   type_vocab_size
						SCREAMING_SNAKE_CASE__										=   2
						SCREAMING_SNAKE_CASE__										=   num_labels
						SCREAMING_SNAKE_CASE__										=   num_choices
						SCREAMING_SNAKE_CASE__										=   scope
						SCREAMING_SNAKE_CASE__										=   initializer_std

						# Used in the tests to check the size of the first attention layer
						SCREAMING_SNAKE_CASE__										=   n_head
						# Used in the tests to check the size of the first hidden state
						SCREAMING_SNAKE_CASE__										=   self.d_model
						# Used in the tests to check the number of output hidden states/attentions
						SCREAMING_SNAKE_CASE__										=   sum(self.block_sizes							) + (0 if base else self.num_decoder_layers)
						# FunnelModel adds two hidden layers: input embeddings and the sum of the upsampled encoder hidden state with
						# the last hidden state of the first block (which is the first hidden state of the decoder).
						if not base:
									SCREAMING_SNAKE_CASE__										=   self.num_hidden_layers + 2

			def        SCREAMING_SNAKE_CASE					(       self					:    Optional[Any]							) ->     Union[str, Any]:
						SCREAMING_SNAKE_CASE__										=   ids_tensor([self.batch_size, self.seq_length]     ,					self.vocab_size							)

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

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

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

						SCREAMING_SNAKE_CASE__										=   FunnelConfig(
						    vocab_size=self.vocab_size     ,					block_sizes=self.block_sizes     ,					num_decoder_layers=self.num_decoder_layers     ,					d_model=self.d_model     ,					n_head=self.n_head     ,					d_head=self.d_head     ,					d_inner=self.d_inner     ,					hidden_act=self.hidden_act     ,					hidden_dropout=self.hidden_dropout     ,					attention_dropout=self.attention_dropout     ,					activation_dropout=self.activation_dropout     ,					max_position_embeddings=self.max_position_embeddings     ,					type_vocab_size=self.type_vocab_size     ,					initializer_std=self.initializer_std     ,					)

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

			def        SCREAMING_SNAKE_CASE					(       self					:    Optional[Any]     ,					__UpperCAmelCase					:    List[Any]     ,					__UpperCAmelCase					:    str     ,					__UpperCAmelCase					:    Optional[int]     ,					__UpperCAmelCase					:    List[str]     ,					__UpperCAmelCase					:    Optional[int]     ,					__UpperCAmelCase					:    Dict     ,					__UpperCAmelCase					:    int     ,					) ->     List[Any]:
						SCREAMING_SNAKE_CASE__										=   TFFunnelModel(config=__UpperCAmelCase							)
						SCREAMING_SNAKE_CASE__										=   {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
						SCREAMING_SNAKE_CASE__										=   model(__UpperCAmelCase							)

						SCREAMING_SNAKE_CASE__										=   [input_ids, input_mask]
						SCREAMING_SNAKE_CASE__										=   model(__UpperCAmelCase							)

						SCREAMING_SNAKE_CASE__										=   model(__UpperCAmelCase							)
						self.parent.assertEqual(result.last_hidden_state.shape     ,					(self.batch_size, self.seq_length, self.d_model)							)

						SCREAMING_SNAKE_CASE__										=   False
						SCREAMING_SNAKE_CASE__										=   TFFunnelModel(config=__UpperCAmelCase							)
						SCREAMING_SNAKE_CASE__										=   model(__UpperCAmelCase							)
						self.parent.assertEqual(result.last_hidden_state.shape     ,					(self.batch_size, self.seq_length, self.d_model)							)

						SCREAMING_SNAKE_CASE__										=   False
						SCREAMING_SNAKE_CASE__										=   TFFunnelModel(config=__UpperCAmelCase							)
						SCREAMING_SNAKE_CASE__										=   model(__UpperCAmelCase							)
						self.parent.assertEqual(result.last_hidden_state.shape     ,					(self.batch_size, self.seq_length, self.d_model)							)

			def        SCREAMING_SNAKE_CASE					(       self					:    int     ,					__UpperCAmelCase					:    Union[str, Any]     ,					__UpperCAmelCase					:    Tuple     ,					__UpperCAmelCase					:    Any     ,					__UpperCAmelCase					:    Union[str, Any]     ,					__UpperCAmelCase					:    Any     ,					__UpperCAmelCase					:    Any     ,					__UpperCAmelCase					:    int     ,					) ->     Tuple:
						SCREAMING_SNAKE_CASE__										=   TFFunnelBaseModel(config=__UpperCAmelCase							)
						SCREAMING_SNAKE_CASE__										=   {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
						SCREAMING_SNAKE_CASE__										=   model(__UpperCAmelCase							)

						SCREAMING_SNAKE_CASE__										=   [input_ids, input_mask]
						SCREAMING_SNAKE_CASE__										=   model(__UpperCAmelCase							)

						SCREAMING_SNAKE_CASE__										=   model(__UpperCAmelCase							)
						self.parent.assertEqual(result.last_hidden_state.shape     ,					(self.batch_size, 2, self.d_model)							)

						SCREAMING_SNAKE_CASE__										=   False
						SCREAMING_SNAKE_CASE__										=   TFFunnelBaseModel(config=__UpperCAmelCase							)
						SCREAMING_SNAKE_CASE__										=   model(__UpperCAmelCase							)
						self.parent.assertEqual(result.last_hidden_state.shape     ,					(self.batch_size, 3, self.d_model)							)

						SCREAMING_SNAKE_CASE__										=   False
						SCREAMING_SNAKE_CASE__										=   TFFunnelBaseModel(config=__UpperCAmelCase							)
						SCREAMING_SNAKE_CASE__										=   model(__UpperCAmelCase							)
						self.parent.assertEqual(result.last_hidden_state.shape     ,					(self.batch_size, 2, self.d_model)							)

			def        SCREAMING_SNAKE_CASE					(       self					:    Dict     ,					__UpperCAmelCase					:    List[str]     ,					__UpperCAmelCase					:    Dict     ,					__UpperCAmelCase					:    str     ,					__UpperCAmelCase					:    List[str]     ,					__UpperCAmelCase					:    Optional[int]     ,					__UpperCAmelCase					:    Dict     ,					__UpperCAmelCase					:    Optional[int]     ,					) ->     Union[str, Any]:
						SCREAMING_SNAKE_CASE__										=   TFFunnelForPreTraining(config=__UpperCAmelCase							)
						SCREAMING_SNAKE_CASE__										=   {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
						SCREAMING_SNAKE_CASE__										=   model(__UpperCAmelCase							)
						self.parent.assertEqual(result.logits.shape     ,					(self.batch_size, self.seq_length)							)

			def        SCREAMING_SNAKE_CASE					(       self					:    int     ,					__UpperCAmelCase					:    int     ,					__UpperCAmelCase					:    List[str]     ,					__UpperCAmelCase					:    Any     ,					__UpperCAmelCase					:    List[str]     ,					__UpperCAmelCase					:    List[str]     ,					__UpperCAmelCase					:    Union[str, Any]     ,					__UpperCAmelCase					:    List[Any]     ,					) ->     List[Any]:
						SCREAMING_SNAKE_CASE__										=   TFFunnelForMaskedLM(config=__UpperCAmelCase							)
						SCREAMING_SNAKE_CASE__										=   {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
						SCREAMING_SNAKE_CASE__										=   model(__UpperCAmelCase							)
						self.parent.assertEqual(result.logits.shape     ,					(self.batch_size, self.seq_length, self.vocab_size)							)

			def        SCREAMING_SNAKE_CASE					(       self					:    Optional[Any]     ,					__UpperCAmelCase					:    Any     ,					__UpperCAmelCase					:    int     ,					__UpperCAmelCase					:    Tuple     ,					__UpperCAmelCase					:    Optional[int]     ,					__UpperCAmelCase					:    Optional[int]     ,					__UpperCAmelCase					:    str     ,					__UpperCAmelCase					:    Tuple     ,					) ->     List[str]:
						SCREAMING_SNAKE_CASE__										=   self.num_labels
						SCREAMING_SNAKE_CASE__										=   TFFunnelForSequenceClassification(config=__UpperCAmelCase							)
						SCREAMING_SNAKE_CASE__										=   {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
						SCREAMING_SNAKE_CASE__										=   model(__UpperCAmelCase							)
						self.parent.assertEqual(result.logits.shape     ,					(self.batch_size, self.num_labels)							)

			def        SCREAMING_SNAKE_CASE					(       self					:    Tuple     ,					__UpperCAmelCase					:    Optional[Any]     ,					__UpperCAmelCase					:    Optional[Any]     ,					__UpperCAmelCase					:    Optional[Any]     ,					__UpperCAmelCase					:    Optional[Any]     ,					__UpperCAmelCase					:    int     ,					__UpperCAmelCase					:    Union[str, Any]     ,					__UpperCAmelCase					:    int     ,					) ->     List[Any]:
						SCREAMING_SNAKE_CASE__										=   self.num_choices
						SCREAMING_SNAKE_CASE__										=   TFFunnelForMultipleChoice(config=__UpperCAmelCase							)
						SCREAMING_SNAKE_CASE__										=   tf.tile(tf.expand_dims(__UpperCAmelCase     ,					1							)     ,					(1, self.num_choices, 1)							)
						SCREAMING_SNAKE_CASE__										=   tf.tile(tf.expand_dims(__UpperCAmelCase     ,					1							)     ,					(1, self.num_choices, 1)							)
						SCREAMING_SNAKE_CASE__										=   tf.tile(tf.expand_dims(__UpperCAmelCase     ,					1							)     ,					(1, self.num_choices, 1)							)
						SCREAMING_SNAKE_CASE__										=   {
						    """input_ids""": multiple_choice_inputs_ids,
						    """attention_mask""": multiple_choice_input_mask,
						    """token_type_ids""": multiple_choice_token_type_ids,
						}
						SCREAMING_SNAKE_CASE__										=   model(__UpperCAmelCase							)
						self.parent.assertEqual(result.logits.shape     ,					(self.batch_size, self.num_choices)							)

			def        SCREAMING_SNAKE_CASE					(       self					:    str     ,					__UpperCAmelCase					:    Any     ,					__UpperCAmelCase					:    Tuple     ,					__UpperCAmelCase					:    List[Any]     ,					__UpperCAmelCase					:    Optional[int]     ,					__UpperCAmelCase					:    Optional[int]     ,					__UpperCAmelCase					:    List[Any]     ,					__UpperCAmelCase					:    str     ,					) ->     Union[str, Any]:
						SCREAMING_SNAKE_CASE__										=   self.num_labels
						SCREAMING_SNAKE_CASE__										=   TFFunnelForTokenClassification(config=__UpperCAmelCase							)
						SCREAMING_SNAKE_CASE__										=   {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
						SCREAMING_SNAKE_CASE__										=   model(__UpperCAmelCase							)
						self.parent.assertEqual(result.logits.shape     ,					(self.batch_size, self.seq_length, self.num_labels)							)

			def        SCREAMING_SNAKE_CASE					(       self					:    Dict     ,					__UpperCAmelCase					:    Optional[Any]     ,					__UpperCAmelCase					:    str     ,					__UpperCAmelCase					:    List[str]     ,					__UpperCAmelCase					:    Tuple     ,					__UpperCAmelCase					:    str     ,					__UpperCAmelCase					:    Union[str, Any]     ,					__UpperCAmelCase					:    int     ,					) ->     Dict:
						SCREAMING_SNAKE_CASE__										=   TFFunnelForQuestionAnswering(config=__UpperCAmelCase							)
						SCREAMING_SNAKE_CASE__										=   {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
						SCREAMING_SNAKE_CASE__										=   model(__UpperCAmelCase							)
						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        SCREAMING_SNAKE_CASE					(       self					:    List[str]							) ->     Any:
						SCREAMING_SNAKE_CASE__										=   self.prepare_config_and_inputs()
						(
						    (
						    SCREAMING_SNAKE_CASE__
						)				,		(
						    SCREAMING_SNAKE_CASE__
						)				,		(
						    SCREAMING_SNAKE_CASE__
						)				,		(
						    SCREAMING_SNAKE_CASE__
						)				,		(
						    SCREAMING_SNAKE_CASE__
						)				,		(
						    SCREAMING_SNAKE_CASE__
						)				,		(
						    SCREAMING_SNAKE_CASE__
						)				,		
						)										=   config_and_inputs
						SCREAMING_SNAKE_CASE__										=   {"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
						return config, inputs_dict





@require_tf
class  lowerCamelCase    (A__      ,A__      ,unittest.TestCase      ):
			lowerCamelCase__ :		int       		=				(
			    (
			        TFFunnelModel,
			        TFFunnelForMaskedLM,
			        TFFunnelForPreTraining,
			        TFFunnelForQuestionAnswering,
			        TFFunnelForTokenClassification,
			    )
			    if is_tf_available()
			    else ()
			)
			lowerCamelCase__ :		Tuple       		=				(
			    {
			        'feature-extraction': (TFFunnelBaseModel, TFFunnelModel),
			        'fill-mask': TFFunnelForMaskedLM,
			        'question-answering': TFFunnelForQuestionAnswering,
			        'text-classification': TFFunnelForSequenceClassification,
			        'token-classification': TFFunnelForTokenClassification,
			        'zero-shot': TFFunnelForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			lowerCamelCase__ :		str       		=				False
			lowerCamelCase__ :		Any       		=				False

			def        SCREAMING_SNAKE_CASE					(       self					:    Any							) ->     Optional[int]:
						SCREAMING_SNAKE_CASE__										=   TFFunnelModelTester(self							)
						SCREAMING_SNAKE_CASE__										=   ConfigTester(self     ,					config_class=__UpperCAmelCase							)

			def        SCREAMING_SNAKE_CASE					(       self					:    Any							) ->     str:
						self.config_tester.run_common_tests()

			def        SCREAMING_SNAKE_CASE					(       self					:    List[Any]							) ->     str:
						SCREAMING_SNAKE_CASE__										=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*__UpperCAmelCase							)

			def        SCREAMING_SNAKE_CASE					(       self					:    int							) ->     Optional[int]:
						SCREAMING_SNAKE_CASE__										=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_pretraining(*__UpperCAmelCase							)

			def        SCREAMING_SNAKE_CASE					(       self					:    List[str]							) ->     Any:
						SCREAMING_SNAKE_CASE__										=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_lm(*__UpperCAmelCase							)

			def        SCREAMING_SNAKE_CASE					(       self					:    List[str]							) ->     Tuple:
						SCREAMING_SNAKE_CASE__										=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_token_classification(*__UpperCAmelCase							)





			def        SCREAMING_SNAKE_CASE					(       self					:    Tuple							) ->     Tuple:
						SCREAMING_SNAKE_CASE__										=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_question_answering(*__UpperCAmelCase							)





@require_tf
class  lowerCamelCase    (A__      ,unittest.TestCase      ):
			lowerCamelCase__ :		List[Any]       		=				(
			    (TFFunnelBaseModel, TFFunnelForMultipleChoice, TFFunnelForSequenceClassification) if is_tf_available() else ()
			)
			lowerCamelCase__ :		Dict       		=				False
			lowerCamelCase__ :		Tuple       		=				False

			def        SCREAMING_SNAKE_CASE					(       self					:    Any							) ->     Union[str, Any]:
						SCREAMING_SNAKE_CASE__										=   TFFunnelModelTester(self     ,					base=__UpperCAmelCase							)
						SCREAMING_SNAKE_CASE__										=   ConfigTester(self     ,					config_class=__UpperCAmelCase							)

			def        SCREAMING_SNAKE_CASE					(       self					:    Any							) ->     Union[str, Any]:
						self.config_tester.run_common_tests()

			def        SCREAMING_SNAKE_CASE					(       self					:    List[Any]							) ->     str:
						SCREAMING_SNAKE_CASE__										=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_base_model(*__UpperCAmelCase							)

			def        SCREAMING_SNAKE_CASE					(       self					:    Dict							) ->     Any:
						SCREAMING_SNAKE_CASE__										=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_sequence_classification(*__UpperCAmelCase							)





			def        SCREAMING_SNAKE_CASE					(       self					:    Any							) ->     int:
						SCREAMING_SNAKE_CASE__										=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_multiple_choice(*__UpperCAmelCase							)


