






from __future__ import annotations

import unittest

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

					from transformers import (
					    TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
					    TFXLMForMultipleChoice,
					    TFXLMForQuestionAnsweringSimple,
					    TFXLMForSequenceClassification,
					    TFXLMForTokenClassification,
					    TFXLMModel,
					    TFXLMWithLMHeadModel,
					    XLMConfig,
					)
class   UpperCamelCase			:







		"""simple docstring"""



		def __init__(	self		:							List[Any]    ,_SCREAMING_SNAKE_CASE		:							Union[str, Any]    ,)     -> str:


						'''simple docstring'''
						A									=   parent
						A									=   1_3
						A									=   7
						A									=   True
						A									=   True
						A									=   True
						A									=   True
						A									=   True
						A									=   False
						A									=   False
						A									=   False
						A									=   2
						A									=   9_9
						A									=   0
						A									=   3_2
						A									=   2
						A									=   4
						A									=   0.1
						A									=   0.1
						A									=   5_1_2
						A									=   1_6
						A									=   2
						A									=   0.02
						A									=   3
						A									=   4
						A									=   'last'
						A									=   True
						A									=   None
						A									=   0
		def    A(	self		:							Dict		)     -> Union[str, Any]:


						'''simple docstring'''
						A									=   ids_tensor([self.batch_size, self.seq_length]    ,self.vocab_size		)
						A									=   random_attention_mask([self.batch_size, self.seq_length]    ,dtype=tf.floataa		)

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

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

						A									=   None
						A									=   None
						A									=   None
						if self.use_labels:
										A									=   ids_tensor([self.batch_size]    ,self.type_sequence_label_size		)
										A									=   ids_tensor([self.batch_size, self.seq_length]    ,self.num_labels		)
										A									=   ids_tensor([self.batch_size]    ,2    ,dtype=tf.floataa		)
										A									=   ids_tensor([self.batch_size]    ,self.num_choices		)

						A									=   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    ,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    A(	self		:							Optional[Any]    ,_SCREAMING_SNAKE_CASE		:							Dict    ,_SCREAMING_SNAKE_CASE		:							Any    ,_SCREAMING_SNAKE_CASE		:							List[str]    ,_SCREAMING_SNAKE_CASE		:							Any    ,_SCREAMING_SNAKE_CASE		:							int    ,_SCREAMING_SNAKE_CASE		:							Tuple    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]    ,_SCREAMING_SNAKE_CASE		:							int    ,_SCREAMING_SNAKE_CASE		:							Any    ,)     -> Optional[int]:


						'''simple docstring'''
						A									=   TFXLMModel(config=_SCREAMING_SNAKE_CASE		)
						A									=   {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
						A									=   model(_SCREAMING_SNAKE_CASE		)

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


						'''simple docstring'''
						A									=   TFXLMWithLMHeadModel(_SCREAMING_SNAKE_CASE		)

						A									=   {'input_ids': input_ids, 'lengths': input_lengths, 'langs': token_type_ids}
						A									=   model(_SCREAMING_SNAKE_CASE		)

						A									=   outputs

						self.parent.assertEqual(result.logits.shape    ,(self.batch_size, self.seq_length, self.vocab_size)		)
		def    A(	self		:							List[str]    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]    ,_SCREAMING_SNAKE_CASE		:							List[Any]    ,_SCREAMING_SNAKE_CASE		:							Optional[int]    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]    ,_SCREAMING_SNAKE_CASE		:							int    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]    ,_SCREAMING_SNAKE_CASE		:							List[Any]    ,_SCREAMING_SNAKE_CASE		:							str    ,_SCREAMING_SNAKE_CASE		:							Any    ,)     -> List[str]:


						'''simple docstring'''
						A									=   TFXLMForQuestionAnsweringSimple(_SCREAMING_SNAKE_CASE		)

						A									=   {'input_ids': input_ids, 'lengths': input_lengths}

						A									=   model(_SCREAMING_SNAKE_CASE		)

						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		:							Optional[Any]    ,_SCREAMING_SNAKE_CASE		:							List[Any]    ,_SCREAMING_SNAKE_CASE		:							Any    ,_SCREAMING_SNAKE_CASE		:							Tuple    ,_SCREAMING_SNAKE_CASE		:							Union[str, Any]    ,_SCREAMING_SNAKE_CASE		:							Dict    ,_SCREAMING_SNAKE_CASE		:							Optional[int]    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]    ,_SCREAMING_SNAKE_CASE		:							Dict    ,_SCREAMING_SNAKE_CASE		:							int    ,)     -> Optional[int]:


						'''simple docstring'''
						A									=   TFXLMForSequenceClassification(_SCREAMING_SNAKE_CASE		)

						A									=   {'input_ids': input_ids, 'lengths': input_lengths}

						A									=   model(_SCREAMING_SNAKE_CASE		)

						self.parent.assertEqual(result.logits.shape    ,(self.batch_size, self.type_sequence_label_size)		)
		def    A(	self		:							int    ,_SCREAMING_SNAKE_CASE		:							Tuple    ,_SCREAMING_SNAKE_CASE		:							int    ,_SCREAMING_SNAKE_CASE		:							str    ,_SCREAMING_SNAKE_CASE		:							Union[str, Any]    ,_SCREAMING_SNAKE_CASE		:							Tuple    ,_SCREAMING_SNAKE_CASE		:							Dict    ,_SCREAMING_SNAKE_CASE		:							Optional[int]    ,_SCREAMING_SNAKE_CASE		:							Union[str, Any]    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]    ,)     -> Union[str, Any]:


						'''simple docstring'''
						A									=   self.num_labels
						A									=   TFXLMForTokenClassification(config=_SCREAMING_SNAKE_CASE		)
						A									=   {'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
						A									=   model(_SCREAMING_SNAKE_CASE		)
						self.parent.assertEqual(result.logits.shape    ,(self.batch_size, self.seq_length, self.num_labels)		)
		def    A(	self		:							int    ,_SCREAMING_SNAKE_CASE		:							List[str]    ,_SCREAMING_SNAKE_CASE		:							Union[str, Any]    ,_SCREAMING_SNAKE_CASE		:							Optional[Any]    ,_SCREAMING_SNAKE_CASE		:							Optional[int]    ,_SCREAMING_SNAKE_CASE		:							List[Any]    ,_SCREAMING_SNAKE_CASE		:							Union[str, Any]    ,_SCREAMING_SNAKE_CASE		:							Tuple    ,_SCREAMING_SNAKE_CASE		:							Tuple    ,_SCREAMING_SNAKE_CASE		:							Dict    ,)     -> Tuple:


						'''simple docstring'''
						A									=   self.num_choices
						A									=   TFXLMForMultipleChoice(config=_SCREAMING_SNAKE_CASE		)
						A									=   tf.tile(tf.expand_dims(_SCREAMING_SNAKE_CASE    ,1		)    ,(1, self.num_choices, 1)		)
						A									=   tf.tile(tf.expand_dims(_SCREAMING_SNAKE_CASE    ,1		)    ,(1, self.num_choices, 1)		)
						A									=   tf.tile(tf.expand_dims(_SCREAMING_SNAKE_CASE    ,1		)    ,(1, self.num_choices, 1)		)
						A									=   {
						    'input_ids': multiple_choice_inputs_ids,
						    'attention_mask': multiple_choice_input_mask,
						    'token_type_ids': multiple_choice_token_type_ids,
						}
						A									=   model(_SCREAMING_SNAKE_CASE		)
						self.parent.assertEqual(result.logits.shape    ,(self.batch_size, self.num_choices)		)







		def    A(	self		:							Optional[int]		)     -> Tuple:


						'''simple docstring'''
						A									=   self.prepare_config_and_inputs()
						(
						    (
						    A
						)			,		(
						    A
						)			,		(
						    A
						)			,		(
						    A
						)			,		(
						    A
						)			,		(
						    A
						)			,		(
						    A
						)			,		(
						    A
						)			,		(
						    A
						)			,		
						)									=   config_and_inputs
						A									=   {
						    'input_ids': input_ids,
						    'token_type_ids': token_type_ids,
						    'langs': token_type_ids,
						    'lengths': input_lengths,
						}
						return config, inputs_dict


@require_tf
class   UpperCamelCase			(					snake_case__      ,							snake_case__      ,							unittest.TestCase			):







		"""simple docstring"""



		snake_case			 = (
		    (
		        TFXLMModel,
		        TFXLMWithLMHeadModel,
		        TFXLMForSequenceClassification,
		        TFXLMForQuestionAnsweringSimple,
		        TFXLMForTokenClassification,
		        TFXLMForMultipleChoice,
		    )
		    if is_tf_available()
		    else ()
		)
		snake_case			 = (
		    (TFXLMWithLMHeadModel,) if is_tf_available() else ()
		)  # TODO (PVP): Check other models whether language generation is also applicable
		snake_case			 = (
		    {
		        "feature-extraction": TFXLMModel,
		        "fill-mask": TFXLMWithLMHeadModel,
		        "question-answering": TFXLMForQuestionAnsweringSimple,
		        "text-classification": TFXLMForSequenceClassification,
		        "text-generation": TFXLMWithLMHeadModel,
		        "token-classification": TFXLMForTokenClassification,
		        "zero-shot": TFXLMForSequenceClassification,
		    }
		    if is_tf_available()
		    else {}
		)
		snake_case			 = False
		snake_case			 = False
		def    A(	self		:							List[str]    ,_SCREAMING_SNAKE_CASE		:							Optional[int]    ,_SCREAMING_SNAKE_CASE		:							List[Any]    ,_SCREAMING_SNAKE_CASE		:							List[Any]    ,_SCREAMING_SNAKE_CASE		:							Tuple    ,_SCREAMING_SNAKE_CASE		:							str		)     -> str:


						'''simple docstring'''
						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		:							Optional[int]		)     -> List[Any]:


						'''simple docstring'''
						A									=   TFXLMModelTester(self		)
						A									=   ConfigTester(self    ,config_class=_SCREAMING_SNAKE_CASE    ,emb_dim=3_7		)
		def    A(	self		:							Optional[Any]		)     -> Union[str, Any]:


						'''simple docstring'''
						self.config_tester.run_common_tests()
		def    A(	self		:							List[str]		)     -> Optional[int]:


						'''simple docstring'''
						A									=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_xlm_model(*_SCREAMING_SNAKE_CASE		)
		def    A(	self		:							Optional[int]		)     -> str:


						'''simple docstring'''
						A									=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_xlm_lm_head(*_SCREAMING_SNAKE_CASE		)
		def    A(	self		:							Optional[Any]		)     -> str:


						'''simple docstring'''
						A									=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_xlm_qa(*_SCREAMING_SNAKE_CASE		)
		def    A(	self		:							List[Any]		)     -> str:


						'''simple docstring'''
						A									=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_xlm_sequence_classif(*_SCREAMING_SNAKE_CASE		)
		def    A(	self		:							int		)     -> Optional[int]:


						'''simple docstring'''
						A									=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_xlm_for_token_classification(*_SCREAMING_SNAKE_CASE		)
		def    A(	self		:							List[Any]		)     -> Optional[Any]:


						'''simple docstring'''
						A									=   self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_xlm_for_multiple_choice(*_SCREAMING_SNAKE_CASE		)







		@slow
		def    A(	self		:							Union[str, Any]		)     -> int:


						'''simple docstring'''
						for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										A									=   TFXLMModel.from_pretrained(_SCREAMING_SNAKE_CASE		)
										self.assertIsNotNone(_SCREAMING_SNAKE_CASE		)


@require_tf
class   UpperCamelCase			(					unittest.TestCase			):







		"""simple docstring"""



		@slow
		def    A(	self		:							str		)     -> str:


						'''simple docstring'''
						A									=   TFXLMWithLMHeadModel.from_pretrained('xlm-mlm-en-2048'		)
						A									=   tf.convert_to_tensor([[1_4, 4_4_7]]    ,dtype=tf.intaa		)  # the president
						A									=   [
						    1_4,
						    4_4_7,
						    1_4,
						    4_4_7,
						    1_4,
						    4_4_7,
						    1_4,
						    4_4_7,
						    1_4,
						    4_4_7,
						    1_4,
						    4_4_7,
						    1_4,
						    4_4_7,
						    1_4,
						    4_4_7,
						    1_4,
						    4_4_7,
						    1_4,
						    4_4_7,
						]  # 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
						A									=   model.generate(_SCREAMING_SNAKE_CASE    ,do_sample=_SCREAMING_SNAKE_CASE		)
						self.assertListEqual(output_ids[0].numpy().tolist()    ,_SCREAMING_SNAKE_CASE		)













import hashlib
import importlib.util
import json
import os
import pathlib
from types import ModuleType

import pytest
import requests

lowerCAmelCase_     =			pathlib.Path.cwd().joinpath('project_euler')
lowerCAmelCase_     =			pathlib.Path.cwd().joinpath(
    'scripts', 'project_euler_answers.json'
)

with open(PROJECT_EULER_ANSWERS_PATH) as file_handle:
					lowerCAmelCase_     =			json.load(file_handle)







def   snake_case		(				UpperCAmelCase						:							pathlib.Path ):
				A									=   importlib.util.spec_from_file_location(file_path.name,    str(UpperCAmelCase ) )
				A									=   importlib.util.module_from_spec(UpperCAmelCase )  # type: ignore
				spec.loader.exec_module(UpperCAmelCase )  # type: ignore
				return module







def   snake_case		(				):
				A									=   []
				for problem_dir_path in PROJECT_EULER_DIR_PATH.iterdir():
								if problem_dir_path.is_file() or problem_dir_path.name.startswith('_' ):
												continue
								for file_path in problem_dir_path.iterdir():
												if file_path.suffix != ".py" or file_path.name.startswith(('_', 'test') ):
																continue
												solution_file_paths.append(UpperCAmelCase )
				return solution_file_paths







def   snake_case		(				):
				with open(os.environ['GITHUB_EVENT_PATH'] ) as file:
								A									=   json.load(UpperCAmelCase )
				return event["pull_request"]["url"] + "/files"







def   snake_case		(				):
				A									=   []
				A									=   {
				    'Accept': 'application/vnd.github.v3+json',
				    'Authorization': 'token ' + os.environ['GITHUB_TOKEN'],
				}
				A									=   requests.get(get_files_url(),    headers=UpperCAmelCase ).json()
				for file in files:
								A									=   pathlib.Path.cwd().joinpath(file['filename'] )
								if (
								    filepath.suffix != ".py"
								    or filepath.name.startswith(('_', 'test') )
								    or not filepath.name.startswith('sol' )
								):
												continue
								solution_file_paths.append(UpperCAmelCase )
				return solution_file_paths







def   snake_case		(				):
				if os.environ.get('CI' ) and os.environ.get('GITHUB_EVENT_NAME' ) == "pull_request":
								# Return only if there are any, otherwise default to all solutions
								if filepaths := added_solution_file_path():
												return filepaths
				return all_solution_file_paths()







@pytest.mark.parametrize(
    'solution_path',    collect_solution_file_paths(),    ids=lambda UpperCAmelCase : f'{path.parent.name}/{path.name}',    )
def   snake_case		(				UpperCAmelCase						:							pathlib.Path ):
				A									=   solution_path.parent.name[8:].zfill(3 )
				A									=   PROBLEM_ANSWERS[problem_number]
				A									=   convert_path_to_module(UpperCAmelCase )
				A									=   str(solution_module.solution() )  # type: ignore
				A									=   hashlib.shaaaa(answer.encode() ).hexdigest()
				assert (
				    answer == expected
				), f'Expected solution to {problem_number} to have hash {expected}, got {answer}'





