
import unittest

from transformers import XLMConfig, 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 (
        XLMForMultipleChoice,
        XLMForQuestionAnswering,
        XLMForQuestionAnsweringSimple,
        XLMForSequenceClassification,
        XLMForTokenClassification,
        XLMModel,
        XLMWithLMHeadModel,
    )
    from transformers.models.xlm.modeling_xlm import XLM_PRETRAINED_MODEL_ARCHIVE_LIST




class 					_SCREAMING_SNAKE_CASE  :
      def __init__(			self		,	lowerCamelCase		,	lowerCamelCase=13		,	lowerCamelCase=7		,	lowerCamelCase=True		,	lowerCamelCase=True		,	lowerCamelCase=True		,	lowerCamelCase=True		,	lowerCamelCase=True		,	lowerCamelCase=False		,	lowerCamelCase=False		,	lowerCamelCase=False		,	lowerCamelCase=2		,	lowerCamelCase=99		,	lowerCamelCase=0		,	lowerCamelCase=32		,	lowerCamelCase=5		,	lowerCamelCase=4		,	lowerCamelCase=0.1		,	lowerCamelCase=0.1		,	lowerCamelCase=5_12		,	lowerCamelCase=2		,	lowerCamelCase=0.0_2		,	lowerCamelCase=2		,	lowerCamelCase=4		,	lowerCamelCase="last"		,	lowerCamelCase=True		,	lowerCamelCase=None		,	lowerCamelCase=0		,	):
          snake_case__						=				parent
          snake_case__						=				batch_size
          snake_case__						=				seq_length
          snake_case__						=				is_training
          snake_case__						=				use_input_lengths
          snake_case__						=				use_token_type_ids
          snake_case__						=				use_labels
          snake_case__						=				gelu_activation
          snake_case__						=				sinusoidal_embeddings
          snake_case__						=				causal
          snake_case__						=				asm
          snake_case__						=				n_langs
          snake_case__						=				vocab_size
          snake_case__						=				n_special
          snake_case__						=				hidden_size
          snake_case__						=				num_hidden_layers
          snake_case__						=				num_attention_heads
          snake_case__						=				hidden_dropout_prob
          snake_case__						=				attention_probs_dropout_prob
          snake_case__						=				max_position_embeddings
          snake_case__						=				type_sequence_label_size
          snake_case__						=				initializer_range
          snake_case__						=				num_labels
          snake_case__						=				num_choices
          snake_case__						=				summary_type
          snake_case__						=				use_proj
          snake_case__						=				scope
          snake_case__						=				bos_token_id
      def A_			(			self ):
          snake_case__						=				ids_tensor([self.batch_size, self.seq_length]		,	self.vocab_size )
          snake_case__						=				random_attention_mask([self.batch_size, self.seq_length] )

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

          snake_case__						=				None
          if self.use_token_type_ids:
              snake_case__						=				ids_tensor([self.batch_size, self.seq_length]		,	self.n_langs )

          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]		,	2 ).float()
              snake_case__						=				ids_tensor([self.batch_size]		,	self.num_choices )

          snake_case__						=				self.get_config()

          return (
              config,
              input_ids,
              token_type_ids,
              input_lengths,
              sequence_labels,
              token_labels,
              is_impossible_labels,
              choice_labels,
              input_mask,
          )
      def A_			(			self ):
          return XLMConfig(
              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		,	num_labels=self.num_labels		,	bos_token_id=self.bos_token_id		,	)
      def A_			(			self		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	):
          snake_case__						=				XLMModel(config=lowerCamelCase )
          model.to(lowerCamelCase )
          model.eval()
          snake_case__						=				model(lowerCamelCase		,	lengths=lowerCamelCase		,	langs=lowerCamelCase )
          snake_case__						=				model(lowerCamelCase		,	langs=lowerCamelCase )
          snake_case__						=				model(lowerCamelCase )
          self.parent.assertEqual(result.last_hidden_state.shape		,	(self.batch_size, self.seq_length, self.hidden_size) )
      def A_			(			self		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	):
          snake_case__						=				XLMWithLMHeadModel(lowerCamelCase )
          model.to(lowerCamelCase )
          model.eval()

          snake_case__						=				model(lowerCamelCase		,	token_type_ids=lowerCamelCase		,	labels=lowerCamelCase )
          self.parent.assertEqual(result.loss.shape		,	() )
          self.parent.assertEqual(result.logits.shape		,	(self.batch_size, self.seq_length, self.vocab_size) )
      def A_			(			self		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	):
          snake_case__						=				XLMForQuestionAnsweringSimple(lowerCamelCase )
          model.to(lowerCamelCase )
          model.eval()

          snake_case__						=				model(lowerCamelCase )

          snake_case__						=				model(lowerCamelCase		,	start_positions=lowerCamelCase		,	end_positions=lowerCamelCase )
          snake_case__						=				outputs
          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 A_			(			self		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	):
          snake_case__						=				XLMForQuestionAnswering(lowerCamelCase )
          model.to(lowerCamelCase )
          model.eval()

          snake_case__						=				model(lowerCamelCase )

          snake_case__						=				model(
              lowerCamelCase		,	start_positions=lowerCamelCase		,	end_positions=lowerCamelCase		,	cls_index=lowerCamelCase		,	is_impossible=lowerCamelCase		,	p_mask=lowerCamelCase		,	)

          snake_case__						=				model(
              lowerCamelCase		,	start_positions=lowerCamelCase		,	end_positions=lowerCamelCase		,	cls_index=lowerCamelCase		,	is_impossible=lowerCamelCase		,	)

          ((snake_case__					)						,										)						=				result_with_labels.to_tuple()

          snake_case__						=				model(lowerCamelCase		,	start_positions=lowerCamelCase		,	end_positions=lowerCamelCase )

          ((snake_case__					)						,										)						=				result_with_labels.to_tuple()

          self.parent.assertEqual(result_with_labels.loss.shape		,	() )
          self.parent.assertEqual(result.start_top_log_probs.shape		,	(self.batch_size, model.config.start_n_top) )
          self.parent.assertEqual(result.start_top_index.shape		,	(self.batch_size, model.config.start_n_top) )
          self.parent.assertEqual(
              result.end_top_log_probs.shape		,	(self.batch_size, model.config.start_n_top * model.config.end_n_top) )
          self.parent.assertEqual(
              result.end_top_index.shape		,	(self.batch_size, model.config.start_n_top * model.config.end_n_top) )
          self.parent.assertEqual(result.cls_logits.shape		,	(self.batch_size,) )
      def A_			(			self		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	):
          snake_case__						=				XLMForSequenceClassification(lowerCamelCase )
          model.to(lowerCamelCase )
          model.eval()

          snake_case__						=				model(lowerCamelCase )
          snake_case__						=				model(lowerCamelCase		,	labels=lowerCamelCase )
          self.parent.assertEqual(result.loss.shape		,	() )
          self.parent.assertEqual(result.logits.shape		,	(self.batch_size, self.type_sequence_label_size) )
      def A_			(			self		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	):
          snake_case__						=				self.num_labels
          snake_case__						=				XLMForTokenClassification(lowerCamelCase )
          model.to(lowerCamelCase )
          model.eval()

          snake_case__						=				model(lowerCamelCase		,	attention_mask=lowerCamelCase		,	labels=lowerCamelCase )
          self.parent.assertEqual(result.logits.shape		,	(self.batch_size, self.seq_length, self.num_labels) )
      def A_			(			self		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	):
          snake_case__						=				self.num_choices
          snake_case__						=				XLMForMultipleChoice(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 A_			(			self ):
          snake_case__						=				self.prepare_config_and_inputs()
          (
              (
              snake_case__					
          )						,					(
              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, "lengths": input_lengths}
          return config, inputs_dict





@require_torch
class 					_SCREAMING_SNAKE_CASE  (      __UpperCamelCase       ,					__UpperCamelCase       ,					__UpperCamelCase       ,					unittest.TestCase ):
      _A						:		Optional[int]    	=     (
          (
              XLMModel,
              XLMWithLMHeadModel,
              XLMForQuestionAnswering,
              XLMForSequenceClassification,
              XLMForQuestionAnsweringSimple,
              XLMForTokenClassification,
              XLMForMultipleChoice,
          )
          if is_torch_available()
          else ()
      )
      _A						:		List[Any]    	=     (
          (XLMWithLMHeadModel,) if is_torch_available() else ()
      )  # TODO (PVP): Check other models whether language generation is also applicable
      _A						:		Tuple    	=     (
          {
              'feature-extraction': XLMModel,
              'fill-mask': XLMWithLMHeadModel,
              'question-answering': XLMForQuestionAnsweringSimple,
              'text-classification': XLMForSequenceClassification,
              'text-generation': XLMWithLMHeadModel,
              'token-classification': XLMForTokenClassification,
              'zero-shot': XLMForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )
      def A_			(			self		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase ):
          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 A_			(			self		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase=False ):
          snake_case__						=				super()._prepare_for_class(lowerCamelCase		,	lowerCamelCase		,	return_labels=lowerCamelCase )

          if return_labels:
              if model_class.__name__ == "XLMForQuestionAnswering":
                  snake_case__						=				torch.zeros(
                      self.model_tester.batch_size		,	dtype=torch.long		,	device=lowerCamelCase )
                  snake_case__						=				torch.zeros(
                      self.model_tester.batch_size		,	dtype=torch.long		,	device=lowerCamelCase )

          return inputs_dict
      def A_			(			self ):
          snake_case__						=				XLMModelTester(self )
          snake_case__						=				ConfigTester(self		,	config_class=lowerCamelCase		,	emb_dim=37 )
      def A_			(			self ):
          self.config_tester.run_common_tests()
      def A_			(			self ):
          snake_case__						=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_model(*lowerCamelCase )
      def A_			(			self ):
          snake_case__						=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_lm_head(*lowerCamelCase )
      def A_			(			self ):
          snake_case__						=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_simple_qa(*lowerCamelCase )
      def A_			(			self ):
          snake_case__						=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_qa(*lowerCamelCase )
      def A_			(			self ):
          snake_case__						=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_sequence_classif(*lowerCamelCase )
      def A_			(			self ):
          snake_case__						=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_token_classif(*lowerCamelCase )
      def A_			(			self ):
          snake_case__						=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_xlm_for_multiple_choice(*lowerCamelCase )
      def A_			(			self		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase=False		,	lowerCamelCase=1 ):
          self.assertIsInstance(lowerCamelCase		,	lowerCamelCase )
          self.assertListEqual(
              [isinstance(lowerCamelCase		,	lowerCamelCase ) for iter_attentions in attentions]		,	[True] * len(lowerCamelCase ) )
          self.assertEqual(len(lowerCamelCase )		,	(max_length - min_length) * num_beam_groups )

          for idx, iter_attentions in enumerate(lowerCamelCase ):
              # adds PAD dummy token
              snake_case__						=				min_length + idx + 1
              snake_case__						=				min_length + idx + 1

              snake_case__						=				(
                  batch_size * num_beam_groups,
                  config.num_attention_heads,
                  tgt_len,
                  src_len,
              )
              # check attn size
              self.assertListEqual(
                  [layer_attention.shape for layer_attention in iter_attentions]		,	[expected_shape] * len(lowerCamelCase ) )
      def A_			(			self		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase		,	lowerCamelCase=False		,	lowerCamelCase=1 ):
          self.assertIsInstance(lowerCamelCase		,	lowerCamelCase )
          self.assertListEqual(
              [isinstance(lowerCamelCase		,	lowerCamelCase ) for iter_hidden_states in hidden_states]		,	[True] * len(lowerCamelCase )		,	)
          self.assertEqual(len(lowerCamelCase )		,	(max_length - min_length) * num_beam_groups )

          for idx, iter_hidden_states in enumerate(lowerCamelCase ):
              # adds PAD dummy token
              snake_case__						=				min_length + idx + 1
              snake_case__						=				(batch_size * num_beam_groups, seq_len, config.hidden_size)
              # check hidden size
              self.assertListEqual(
                  [layer_hidden_states.shape for layer_hidden_states in iter_hidden_states]		,	[expected_shape] * len(lowerCamelCase )		,	)
          pass



      @slow
      def A_			(			self ):
          for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              snake_case__						=				XLMModel.from_pretrained(lowerCamelCase )
              self.assertIsNotNone(lowerCamelCase )





@require_torch
class 					_SCREAMING_SNAKE_CASE  (      unittest.TestCase ):
      @slow
      def A_			(			self ):
          snake_case__						=				XLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048" )
          model.to(lowerCamelCase )
          snake_case__						=				torch.tensor([[14, 4_47]]		,	dtype=torch.long		,	device=lowerCamelCase )  # the president
          snake_case__						=				[
              14,
              4_47,
              14,
              4_47,
              14,
              4_47,
              14,
              4_47,
              14,
              4_47,
              14,
              4_47,
              14,
              4_47,
              14,
              4_47,
              14,
              4_47,
              14,
              4_47,
          ]  # the president the president the president the president the president the president the president the president the president the president
          # TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
          snake_case__						=				model.generate(lowerCamelCase		,	do_sample=lowerCamelCase )
          self.assertListEqual(output_ids[0].cpu().numpy().tolist()		,	lowerCamelCase )





from __future__ import annotations

from fractions import Fraction





def 	SCREAMING_SNAKE_CASE__    (      __lowerCAmelCase    ,		__lowerCAmelCase							):
    return (
        num != den and num % 10 == den // 10 and (num // 10) / (den % 10) == num / den
    )





def 	SCREAMING_SNAKE_CASE__    (      __lowerCAmelCase							):
    snake_case__						=				[]
    snake_case__						=				11
    snake_case__						=				int("1" + "0" * digit_len							)
    for num in range(__lowerCAmelCase    ,		__lowerCAmelCase							):
        while den <= 99:
            if (num != den) and (num % 10 == den // 10) and (den % 10 != 0):
                if is_digit_cancelling(__lowerCAmelCase    ,		__lowerCAmelCase							):
                    solutions.append(F"""{num}/{den}"""							)
            den += 1
        num += 1
        snake_case__						=				10
    return solutions





def 	SCREAMING_SNAKE_CASE__    (      __lowerCAmelCase = 2							):
    snake_case__						=				1.0
    for fraction in fraction_list(__lowerCAmelCase							):
        snake_case__						=				Fraction(__lowerCAmelCase							)
        result *= frac.denominator / frac.numerator
    return int(__lowerCAmelCase							)


if __name__ == "__main__":
     print(solution())



