'''simple docstring'''





import unittest

from transformers import FunnelConfig, FunnelTokenizer, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch

     from transformers import (
         MODEL_FOR_PRETRAINING_MAPPING,
         FunnelBaseModel,
         FunnelForMaskedLM,
         FunnelForMultipleChoice,
         FunnelForPreTraining,
         FunnelForQuestionAnswering,
         FunnelForSequenceClassification,
         FunnelForTokenClassification,
         FunnelModel,
     )



class  lowerCAmelCase__   :



  '''simple docstring'''






  def __init__(self  : List[Any]	, lowerCAmelCase_  : Optional[Any]	, lowerCAmelCase_  : Tuple=13	, lowerCAmelCase_  : Tuple=7	, lowerCAmelCase_  : Optional[Any]=True	, lowerCAmelCase_  : List[str]=True	, lowerCAmelCase_  : str=True	, lowerCAmelCase_  : str=True	, lowerCAmelCase_  : str=99	, lowerCAmelCase_  : int=[1, 1, 2]	, lowerCAmelCase_  : Any=1	, lowerCAmelCase_  : Union[str, Any]=32	, lowerCAmelCase_  : Dict=4	, lowerCAmelCase_  : List[Any]=8	, lowerCAmelCase_  : int=37	, lowerCAmelCase_  : int="gelu_new"	, lowerCAmelCase_  : Optional[Any]=0.1	, lowerCAmelCase_  : Dict=0.1	, lowerCAmelCase_  : List[Any]=0.0	, lowerCAmelCase_  : List[Any]=5_12	, lowerCAmelCase_  : int=3	, lowerCAmelCase_  : Union[str, Any]=0.02	, lowerCAmelCase_  : Union[str, Any]=3	, lowerCAmelCase_  : Tuple=4	, lowerCAmelCase_  : int=None	, lowerCAmelCase_  : List[str]=False	, )   ->       List[Any]:
        snake_case_						       =							parent
        snake_case_						       =							batch_size
        snake_case_						       =							seq_length
        snake_case_						       =							is_training
        snake_case_						       =							use_input_mask
        snake_case_						       =							use_token_type_ids
        snake_case_						       =							use_labels
        snake_case_						       =							vocab_size
        snake_case_						       =							block_sizes
        snake_case_						       =							num_decoder_layers
        snake_case_						       =							d_model
        snake_case_						       =							n_head
        snake_case_						       =							d_head
        snake_case_						       =							d_inner
        snake_case_						       =							hidden_act
        snake_case_						       =							hidden_dropout
        snake_case_						       =							attention_dropout
        snake_case_						       =							activation_dropout
        snake_case_						       =							max_position_embeddings
        snake_case_						       =							type_vocab_size
        snake_case_						       =							2
        snake_case_						       =							num_labels
        snake_case_						       =							num_choices
        snake_case_						       =							scope
        snake_case_						       =							initializer_std

        # Used in the tests to check the size of the first attention layer
        snake_case_						       =							n_head
        # Used in the tests to check the size of the first hidden state
        snake_case_						       =							self.d_model
        # Used in the tests to check the number of output hidden states/attentions
        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:
              snake_case_						       =							self.num_hidden_layers + 2

  def 		_lowerCamelCase	(self  : Tuple    )   ->       Any:
        snake_case_						       =							ids_tensor([self.batch_size, self.seq_length]	, self.vocab_size    )

        snake_case_						       =							None
        if self.use_input_mask:
              snake_case_						       =							ids_tensor([self.batch_size, self.seq_length]	, vocab_size=2    )

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

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

        snake_case_						       =							self.get_config()

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

  def 		_lowerCamelCase	(self  : Optional[Any]    )   ->       Tuple:
        return 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	, )

  def 		_lowerCamelCase	(self  : int	, lowerCAmelCase_  : Union[str, Any]	, lowerCAmelCase_  : int	, lowerCAmelCase_  : Dict	, lowerCAmelCase_  : Dict	, lowerCAmelCase_  : Tuple	, lowerCAmelCase_  : Optional[Any]	, lowerCAmelCase_  : Any	, lowerCAmelCase_  : str	, )   ->       List[str]:
        snake_case_						       =							FunnelModel(config=lowerCAmelCase_    )
        model.to(lowerCAmelCase_    )
        model.eval()
        snake_case_						       =							model(lowerCAmelCase_	, attention_mask=lowerCAmelCase_	, token_type_ids=lowerCAmelCase_    )
        snake_case_						       =							model(lowerCAmelCase_	, token_type_ids=lowerCAmelCase_    )
        snake_case_						       =							model(lowerCAmelCase_    )
        self.parent.assertEqual(result.last_hidden_state.shape	, (self.batch_size, self.seq_length, self.d_model)    )

        snake_case_						       =							False
        snake_case_						       =							model(lowerCAmelCase_    )
        self.parent.assertEqual(result.last_hidden_state.shape	, (self.batch_size, self.seq_length, self.d_model)    )

        snake_case_						       =							False
        snake_case_						       =							model(lowerCAmelCase_    )
        self.parent.assertEqual(result.last_hidden_state.shape	, (self.batch_size, self.seq_length, self.d_model)    )

  def 		_lowerCamelCase	(self  : int	, lowerCAmelCase_  : List[Any]	, lowerCAmelCase_  : Optional[Any]	, lowerCAmelCase_  : Any	, lowerCAmelCase_  : Optional[int]	, lowerCAmelCase_  : Optional[Any]	, lowerCAmelCase_  : List[Any]	, lowerCAmelCase_  : List[Any]	, lowerCAmelCase_  : List[Any]	, )   ->       str:
        snake_case_						       =							FunnelBaseModel(config=lowerCAmelCase_    )
        model.to(lowerCAmelCase_    )
        model.eval()
        snake_case_						       =							model(lowerCAmelCase_	, attention_mask=lowerCAmelCase_	, token_type_ids=lowerCAmelCase_    )
        snake_case_						       =							model(lowerCAmelCase_	, token_type_ids=lowerCAmelCase_    )
        snake_case_						       =							model(lowerCAmelCase_    )
        self.parent.assertEqual(result.last_hidden_state.shape	, (self.batch_size, 2, self.d_model)    )

        snake_case_						       =							False
        snake_case_						       =							model(lowerCAmelCase_    )
        self.parent.assertEqual(result.last_hidden_state.shape	, (self.batch_size, 3, self.d_model)    )

        snake_case_						       =							False
        snake_case_						       =							model(lowerCAmelCase_    )
        self.parent.assertEqual(result.last_hidden_state.shape	, (self.batch_size, 2, self.d_model)    )

  def 		_lowerCamelCase	(self  : Optional[Any]	, lowerCAmelCase_  : Any	, lowerCAmelCase_  : List[str]	, lowerCAmelCase_  : Union[str, Any]	, lowerCAmelCase_  : Optional[Any]	, lowerCAmelCase_  : str	, lowerCAmelCase_  : Any	, lowerCAmelCase_  : Optional[int]	, lowerCAmelCase_  : Any	, )   ->       Optional[int]:
        snake_case_						       =							self.num_labels
        snake_case_						       =							FunnelForPreTraining(config=lowerCAmelCase_    )
        model.to(lowerCAmelCase_    )
        model.eval()
        snake_case_						       =							model(lowerCAmelCase_	, attention_mask=lowerCAmelCase_	, token_type_ids=lowerCAmelCase_	, labels=lowerCAmelCase_    )
        self.parent.assertEqual(result.logits.shape	, (self.batch_size, self.seq_length)    )

  def 		_lowerCamelCase	(self  : str	, lowerCAmelCase_  : int	, lowerCAmelCase_  : Union[str, Any]	, lowerCAmelCase_  : List[str]	, lowerCAmelCase_  : Union[str, Any]	, lowerCAmelCase_  : List[Any]	, lowerCAmelCase_  : Optional[int]	, lowerCAmelCase_  : Union[str, Any]	, lowerCAmelCase_  : int	, )   ->       str:
        snake_case_						       =							FunnelForMaskedLM(config=lowerCAmelCase_    )
        model.to(lowerCAmelCase_    )
        model.eval()
        snake_case_						       =							model(lowerCAmelCase_	, attention_mask=lowerCAmelCase_	, token_type_ids=lowerCAmelCase_	, labels=lowerCAmelCase_    )
        self.parent.assertEqual(result.logits.shape	, (self.batch_size, self.seq_length, self.vocab_size)    )

  def 		_lowerCamelCase	(self  : Optional[int]	, lowerCAmelCase_  : int	, lowerCAmelCase_  : str	, lowerCAmelCase_  : Any	, lowerCAmelCase_  : List[Any]	, lowerCAmelCase_  : Optional[Any]	, lowerCAmelCase_  : Optional[int]	, lowerCAmelCase_  : Any	, lowerCAmelCase_  : List[Any]	, )   ->       Tuple:
        snake_case_						       =							self.num_labels
        snake_case_						       =							FunnelForSequenceClassification(lowerCAmelCase_    )
        model.to(lowerCAmelCase_    )
        model.eval()
        snake_case_						       =							model(lowerCAmelCase_	, attention_mask=lowerCAmelCase_	, token_type_ids=lowerCAmelCase_	, labels=lowerCAmelCase_    )
        self.parent.assertEqual(result.logits.shape	, (self.batch_size, self.num_labels)    )

  def 		_lowerCamelCase	(self  : Union[str, Any]	, lowerCAmelCase_  : Union[str, Any]	, lowerCAmelCase_  : List[str]	, lowerCAmelCase_  : Any	, lowerCAmelCase_  : Union[str, Any]	, lowerCAmelCase_  : int	, lowerCAmelCase_  : Tuple	, lowerCAmelCase_  : List[Any]	, lowerCAmelCase_  : str	, )   ->       Union[str, Any]:
        snake_case_						       =							self.num_choices
        snake_case_						       =							FunnelForMultipleChoice(config=lowerCAmelCase_    )
        model.to(lowerCAmelCase_    )
        model.eval()
        snake_case_						       =							input_ids.unsqueeze(1    ).expand(-1	, self.num_choices	, -1    ).contiguous()
        snake_case_						       =							token_type_ids.unsqueeze(1    ).expand(-1	, self.num_choices	, -1    ).contiguous()
        snake_case_						       =							input_mask.unsqueeze(1    ).expand(-1	, self.num_choices	, -1    ).contiguous()
        snake_case_						       =							model(
            lowerCAmelCase_	, attention_mask=lowerCAmelCase_	, token_type_ids=lowerCAmelCase_	, labels=lowerCAmelCase_	, )
        self.parent.assertEqual(result.logits.shape	, (self.batch_size, self.num_choices)    )

  def 		_lowerCamelCase	(self  : int	, lowerCAmelCase_  : Tuple	, lowerCAmelCase_  : List[Any]	, lowerCAmelCase_  : Tuple	, lowerCAmelCase_  : int	, lowerCAmelCase_  : str	, lowerCAmelCase_  : Any	, lowerCAmelCase_  : str	, lowerCAmelCase_  : Any	, )   ->       str:
        snake_case_						       =							self.num_labels
        snake_case_						       =							FunnelForTokenClassification(config=lowerCAmelCase_    )
        model.to(lowerCAmelCase_    )
        model.eval()
        snake_case_						       =							model(lowerCAmelCase_	, attention_mask=lowerCAmelCase_	, token_type_ids=lowerCAmelCase_	, labels=lowerCAmelCase_    )
        self.parent.assertEqual(result.logits.shape	, (self.batch_size, self.seq_length, self.num_labels)    )

  def 		_lowerCamelCase	(self  : Optional[int]	, lowerCAmelCase_  : str	, lowerCAmelCase_  : Union[str, Any]	, lowerCAmelCase_  : str	, lowerCAmelCase_  : Dict	, lowerCAmelCase_  : Any	, lowerCAmelCase_  : List[str]	, lowerCAmelCase_  : Union[str, Any]	, lowerCAmelCase_  : List[Any]	, )   ->       Dict:
        snake_case_						       =							FunnelForQuestionAnswering(config=lowerCAmelCase_    )
        model.to(lowerCAmelCase_    )
        model.eval()
        snake_case_						       =							model(
            lowerCAmelCase_	, attention_mask=lowerCAmelCase_	, token_type_ids=lowerCAmelCase_	, start_positions=lowerCAmelCase_	, end_positions=lowerCAmelCase_	, )
        self.parent.assertEqual(result.start_logits.shape	, (self.batch_size, self.seq_length)    )
        self.parent.assertEqual(result.end_logits.shape	, (self.batch_size, self.seq_length)    )


  def 		_lowerCamelCase	(self  : Union[str, Any]    )   ->       Tuple:
        snake_case_						       =							self.prepare_config_and_inputs()
        (
            (
            snake_case_	
        )       ,	(
            snake_case_	
        )       ,	(
            snake_case_	
        )       ,	(
            snake_case_	
        )       ,	(
            snake_case_	
        )       ,	(
            snake_case_	
        )       ,	(
            snake_case_	
        )       ,	(
            snake_case_	
        )       ,		
        )						       =							config_and_inputs
        snake_case_						       =							{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
        return config, inputs_dict



@require_torch
class  lowerCAmelCase__   (       UpperCamelCase					,							UpperCamelCase					,							unittest.TestCase       ):



  '''simple docstring'''






  _UpperCamelCase						= False
  _UpperCamelCase						= False
  _UpperCamelCase						= (
      (
          FunnelModel,
          FunnelForMaskedLM,
          FunnelForPreTraining,
          FunnelForQuestionAnswering,
          FunnelForTokenClassification,
      )
      if is_torch_available()
      else ()
  )
  _UpperCamelCase						= (
      {
          'feature-extraction': (FunnelBaseModel, FunnelModel),
          'fill-mask': FunnelForMaskedLM,
          'question-answering': FunnelForQuestionAnswering,
          'text-classification': FunnelForSequenceClassification,
          'token-classification': FunnelForTokenClassification,
          'zero-shot': FunnelForSequenceClassification,
      }
      if is_torch_available()
      else {}
  )

  def 		_lowerCamelCase	(self  : List[str]	, lowerCAmelCase_  : Optional[int]	, lowerCAmelCase_  : Dict	, lowerCAmelCase_  : Union[str, Any]=False    )   ->       int:
        snake_case_						       =							super()._prepare_for_class(lowerCAmelCase_	, lowerCAmelCase_	, return_labels=lowerCAmelCase_    )

        if return_labels:
              if model_class in get_values(lowerCAmelCase_    ):
                    snake_case_						       =							torch.zeros(
                        (self.model_tester.batch_size, self.model_tester.seq_length)	, dtype=torch.long	, device=lowerCAmelCase_    )
        return inputs_dict

  def 		_lowerCamelCase	(self  : Optional[Any]    )   ->       Optional[Any]:
        snake_case_						       =							FunnelModelTester(self    )
        snake_case_						       =							ConfigTester(self	, config_class=lowerCAmelCase_    )

  def 		_lowerCamelCase	(self  : Tuple    )   ->       str:
        self.config_tester.run_common_tests()

  def 		_lowerCamelCase	(self  : Any    )   ->       Optional[int]:
        snake_case_						       =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowerCAmelCase_    )

  def 		_lowerCamelCase	(self  : Any    )   ->       Optional[int]:
        snake_case_						       =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_pretraining(*lowerCAmelCase_    )

  def 		_lowerCamelCase	(self  : Optional[int]    )   ->       Dict:
        snake_case_						       =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase_    )

  def 		_lowerCamelCase	(self  : Union[str, Any]    )   ->       List[str]:
        snake_case_						       =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase_    )

  def 		_lowerCamelCase	(self  : Union[str, Any]    )   ->       Tuple:
        snake_case_						       =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase_    )


  def 		_lowerCamelCase	(self  : Optional[Any]	, lowerCAmelCase_  : Dict    )   ->       str:
        if hasattr(lowerCAmelCase_	, "weight"    ) and module.weight is not None:
              module.weight.data.fill_(3    )
        if hasattr(lowerCAmelCase_	, "bias"    ) and module.bias is not None:
              module.bias.data.fill_(3    )

        for param in ["r_w_bias", "r_r_bias", "r_kernel", "r_s_bias", "seg_embed"]:
              if hasattr(lowerCAmelCase_	, lowerCAmelCase_    ) and getattr(lowerCAmelCase_	, lowerCAmelCase_    ) is not None:
                    snake_case_						       =							getattr(lowerCAmelCase_	, lowerCAmelCase_    )
                    weight.data.fill_(3    )



@require_torch
class  lowerCAmelCase__   (       UpperCamelCase					,							unittest.TestCase       ):



  '''simple docstring'''






  _UpperCamelCase						= False
  _UpperCamelCase						= False
  _UpperCamelCase						= (
      (FunnelBaseModel, FunnelForMultipleChoice, FunnelForSequenceClassification) if is_torch_available() else ()
  )

  def 		_lowerCamelCase	(self  : Dict    )   ->       Tuple:
        snake_case_						       =							FunnelModelTester(self	, base=lowerCAmelCase_    )
        snake_case_						       =							ConfigTester(self	, config_class=lowerCAmelCase_    )

  def 		_lowerCamelCase	(self  : Tuple    )   ->       str:
        self.config_tester.run_common_tests()

  def 		_lowerCamelCase	(self  : Dict    )   ->       Any:
        snake_case_						       =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_base_model(*lowerCAmelCase_    )

  def 		_lowerCamelCase	(self  : Optional[Any]    )   ->       List[str]:
        snake_case_						       =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase_    )

  def 		_lowerCamelCase	(self  : Dict    )   ->       List[Any]:
        snake_case_						       =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_multiple_choice(*lowerCAmelCase_    )

  def 		_lowerCamelCase	(self  : Optional[int]    )   ->       List[str]:
        snake_case_       ,	snake_case_						       =							self.model_tester.prepare_config_and_inputs_for_common()
        snake_case_						       =							True

        for model_class in self.all_model_classes:
              if model_class.__name__ == "FunnelBaseModel":
                    continue
              snake_case_						       =							model_class(lowerCAmelCase_    )
              model.to(lowerCAmelCase_    )
              model.train()
              snake_case_						       =							self._prepare_for_class(lowerCAmelCase_	, lowerCAmelCase_	, return_labels=lowerCAmelCase_    )
              snake_case_						       =							model(**lowerCAmelCase_    ).loss
              loss.backward()


  def 		_lowerCamelCase	(self  : Dict	, lowerCAmelCase_  : str    )   ->       Optional[int]:
        if hasattr(lowerCAmelCase_	, "weight"    ) and module.weight is not None:
              module.weight.data.fill_(3    )
        if hasattr(lowerCAmelCase_	, "bias"    ) and module.bias is not None:
              module.bias.data.fill_(3    )

        for param in ["r_w_bias", "r_r_bias", "r_kernel", "r_s_bias", "seg_embed"]:
              if hasattr(lowerCAmelCase_	, lowerCAmelCase_    ) and getattr(lowerCAmelCase_	, lowerCAmelCase_    ) is not None:
                    snake_case_						       =							getattr(lowerCAmelCase_	, lowerCAmelCase_    )
                    weight.data.fill_(3    )



@require_torch
@require_sentencepiece
@require_tokenizers
class  lowerCAmelCase__   (       unittest.TestCase       ):



  '''simple docstring'''






  def 		_lowerCamelCase	(self  : int    )   ->       Any:
        snake_case_						       =							13
        snake_case_						       =							7
        snake_case_						       =							torch.arange(0	, batch_size * sequence_length    ).long().reshape(lowerCAmelCase_	, lowerCAmelCase_    )
        snake_case_						       =							[0, 1, 2, 3, 4, 5, 6, 4, 1, 3, 5, 0, 1]
        snake_case_						       =							torch.tensor([[2] + [0] * a + [1] * (sequence_length - a - 1) for a in lengths]    )

        snake_case_						       =							FunnelModel.from_pretrained("sgugger/funnel-random-tiny"    )
        snake_case_						       =							model(lowerCAmelCase_	, token_type_ids=lowerCAmelCase_    )[0].abs()

        snake_case_						       =							torch.tensor(23_44.83_52    )
        snake_case_						       =							torch.tensor(0.8_052    )
        self.assertTrue(torch.allclose(output.sum()	, lowerCAmelCase_	, atol=1E-4    )    )
        self.assertTrue(torch.allclose(output.mean()	, lowerCAmelCase_	, atol=1E-4    )    )

        snake_case_						       =							torch.tensor([[1] * 7, [1] * 4 + [0] * 3] * 6 + [[0, 1, 1, 0, 0, 1, 1]]    )
        snake_case_						       =							model(lowerCAmelCase_	, attention_mask=lowerCAmelCase_	, token_type_ids=lowerCAmelCase_    )[0].abs()

        snake_case_						       =							torch.tensor(23_43.84_25    )
        snake_case_						       =							torch.tensor(0.8_049    )
        self.assertTrue(torch.allclose(output.sum()	, lowerCAmelCase_	, atol=1E-4    )    )
        self.assertTrue(torch.allclose(output.mean()	, lowerCAmelCase_	, atol=1E-4    )    )


  @slow
  def 		_lowerCamelCase	(self  : List[str]    )   ->       str:
        snake_case_						       =							FunnelTokenizer.from_pretrained("huggingface/funnel-small"    )
        snake_case_						       =							FunnelModel.from_pretrained("huggingface/funnel-small"    )
        snake_case_						       =							tokenizer("Hello! I am the Funnel Transformer model."	, return_tensors="pt"    )
        snake_case_						       =							model(**lowerCAmelCase_    )[0]

        snake_case_						       =							torch.tensor(235.7_246    )
        snake_case_						       =							torch.tensor(0.0_256    )
        self.assertTrue(torch.allclose(output.sum()	, lowerCAmelCase_	, atol=1E-4    )    )
        self.assertTrue(torch.allclose(output.mean()	, lowerCAmelCase_	, atol=1E-4    )    )



'''simple docstring'''





from __future__ import annotations

import random



class  lowerCAmelCase__   :



  '''simple docstring'''






  _UpperCamelCase						= 6

  def __init__(self  : List[Any]    )   ->       Optional[Any]:
        snake_case_						       =							list(range(1	, Dice.NUM_SIDES + 1    )    )


  def 		_lowerCamelCase	(self  : Optional[int]    )   ->       int:
        return random.choice(self.sides    )

def   snake_case_       (							_a     :							int ,					_a     :							int = 2			):
      snake_case_						       =							[Dice() for i in range(_a			)]
      snake_case_						       =							[0] * (len(_a			) * Dice.NUM_SIDES + 1)
      for _ in range(_a			):
            count_of_sum[sum(dice.roll() for dice in dices			)] += 1
      snake_case_						       =							[round((count * 100) / num_throws ,					2			) for count in count_of_sum]
      return probability[num_dice:]  # remove probability of sums that never appear


if __name__ == "__main__":
     import doctest

     doctest.testmod()

