





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    _a     :






							"""simple docstring"""

							def __init__(      self				:     Tuple							,	a				:     Optional[Any]							,	a				:     Union[str, Any]=13							,	a				:     List[str]=7							,	a				:     List[str]=True							,	a				:     Optional[int]=True							,	a				:     Any=True							,	a				:     int=True							,	a				:     List[str]=True							,	a				:     Any=False							,	a				:     int=False							,	a				:     Tuple=False							,	a				:     int=2							,	a				:     Tuple=99							,	a				:     Dict=0							,	a				:     List[str]=32							,	a				:     Dict=5							,	a				:     Optional[int]=4							,	a				:     Tuple=0.1							,	a				:     int=0.1							,	a				:     Union[str, Any]=5_12							,	a				:     Any=2							,	a				:     Optional[Any]=0.02							,	a				:     Dict=2							,	a				:     List[str]=4							,	a				:     List[str]="last"							,	a				:     Optional[Any]=True							,	a				:     Dict=None							,	a				:     Tuple=0							,	)	->str:
													SCREAMING_SNAKE_CASE__     :				List[str]   =					parent
													SCREAMING_SNAKE_CASE__     :				Any   =					batch_size
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					seq_length
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					is_training
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					use_input_lengths
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					use_token_type_ids
													SCREAMING_SNAKE_CASE__     :				Any   =					use_labels
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					gelu_activation
													SCREAMING_SNAKE_CASE__     :				Dict   =					sinusoidal_embeddings
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					causal
													SCREAMING_SNAKE_CASE__     :				List[str]   =					asm
													SCREAMING_SNAKE_CASE__     :				Dict   =					n_langs
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					vocab_size
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					n_special
													SCREAMING_SNAKE_CASE__     :				List[str]   =					hidden_size
													SCREAMING_SNAKE_CASE__     :				Tuple   =					num_hidden_layers
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					num_attention_heads
													SCREAMING_SNAKE_CASE__     :				List[str]   =					hidden_dropout_prob
													SCREAMING_SNAKE_CASE__     :				str   =					attention_probs_dropout_prob
													SCREAMING_SNAKE_CASE__     :				int   =					max_position_embeddings
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					type_sequence_label_size
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					initializer_range
													SCREAMING_SNAKE_CASE__     :				Dict   =					num_labels
													SCREAMING_SNAKE_CASE__     :				str   =					num_choices
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					summary_type
													SCREAMING_SNAKE_CASE__     :				int   =					use_proj
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					scope
													SCREAMING_SNAKE_CASE__     :				int   =					bos_token_id

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

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

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

													SCREAMING_SNAKE_CASE__     :				List[str]   =					None
													SCREAMING_SNAKE_CASE__     :				Dict   =					None
													SCREAMING_SNAKE_CASE__     :				Any   =					None
													if self.use_labels:
																			SCREAMING_SNAKE_CASE__     :				int   =					ids_tensor([self.batch_size]							,	self.type_sequence_label_size    )
																			SCREAMING_SNAKE_CASE__     :				Dict   =					ids_tensor([self.batch_size, self.seq_length]							,	self.num_labels    )
																			SCREAMING_SNAKE_CASE__     :				Any   =					ids_tensor([self.batch_size]							,	2    ).float()
																			SCREAMING_SNAKE_CASE__     :				int   =					ids_tensor([self.batch_size]							,	self.num_choices    )

													SCREAMING_SNAKE_CASE__     :				str   =					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				:     List[str]    )	->Union[str, Any]:
													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				:     Tuple							,	a				:     Optional[Any]							,	a				:     Dict							,	a				:     List[str]							,	a				:     List[Any]							,	a				:     Union[str, Any]							,	a				:     Dict							,	a				:     Dict							,	a				:     Optional[Any]							,	a				:     List[Any]							,	)	->Optional[int]:
													SCREAMING_SNAKE_CASE__     :				Any   =					XLMModel(config=a    )
													model.to(a    )
													model.eval()
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					model(a							,	lengths=a							,	langs=a    )
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					model(a							,	langs=a    )
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					model(a    )
													self.parent.assertEqual(result.last_hidden_state.shape							,	(self.batch_size, self.seq_length, self.hidden_size)    )

							def      A_  (      self				:     List[str]							,	a				:     Optional[Any]							,	a				:     Any							,	a				:     List[Any]							,	a				:     Dict							,	a				:     Union[str, Any]							,	a				:     Any							,	a				:     Tuple							,	a				:     Union[str, Any]							,	a				:     Any							,	)	->List[str]:
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					XLMWithLMHeadModel(a    )
													model.to(a    )
													model.eval()

													SCREAMING_SNAKE_CASE__     :				str   =					model(a							,	token_type_ids=a							,	labels=a    )
													self.parent.assertEqual(result.loss.shape							,	()    )
													self.parent.assertEqual(result.logits.shape							,	(self.batch_size, self.seq_length, self.vocab_size)    )

							def      A_  (      self				:     int							,	a				:     List[str]							,	a				:     List[Any]							,	a				:     Any							,	a				:     Dict							,	a				:     Union[str, Any]							,	a				:     Union[str, Any]							,	a				:     int							,	a				:     List[Any]							,	a				:     Optional[int]							,	)	->Union[str, Any]:
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					XLMForQuestionAnsweringSimple(a    )
													model.to(a    )
													model.eval()

													SCREAMING_SNAKE_CASE__     :				Any   =					model(a    )

													SCREAMING_SNAKE_CASE__     :				Dict   =					model(a							,	start_positions=a							,	end_positions=a    )
													SCREAMING_SNAKE_CASE__     :				int   =					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				:     Union[str, Any]							,	a				:     Optional[int]							,	a				:     List[str]							,	a				:     Optional[int]							,	a				:     Union[str, Any]							,	a				:     Any							,	a				:     Union[str, Any]							,	a				:     Tuple							,	a				:     int							,	a				:     Optional[Any]							,	)	->Union[str, Any]:
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					XLMForQuestionAnswering(a    )
													model.to(a    )
													model.eval()

													SCREAMING_SNAKE_CASE__     :				str   =					model(a    )

													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					model(
													    a							,	start_positions=a							,	end_positions=a							,	cls_index=a							,	is_impossible=a							,	p_mask=a							,	)

													SCREAMING_SNAKE_CASE__     :				Tuple   =					model(
													    a							,	start_positions=a							,	end_positions=a							,	cls_index=a							,	is_impossible=a							,	)

													((SCREAMING_SNAKE_CASE__),							)     :				int   =					result_with_labels.to_tuple()

													SCREAMING_SNAKE_CASE__     :				Tuple   =					model(a							,	start_positions=a							,	end_positions=a    )

													((SCREAMING_SNAKE_CASE__),							)     :				Any   =					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				:     int							,	a				:     int							,	a				:     Union[str, Any]							,	a				:     Union[str, Any]							,	a				:     Tuple							,	a				:     Optional[Any]							,	a				:     Tuple							,	a				:     str							,	a				:     Optional[Any]							,	a				:     Optional[Any]							,	)	->Optional[Any]:
													SCREAMING_SNAKE_CASE__     :				Dict   =					XLMForSequenceClassification(a    )
													model.to(a    )
													model.eval()

													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					model(a    )
													SCREAMING_SNAKE_CASE__     :				Tuple   =					model(a							,	labels=a    )
													self.parent.assertEqual(result.loss.shape							,	()    )
													self.parent.assertEqual(result.logits.shape							,	(self.batch_size, self.type_sequence_label_size)    )

							def      A_  (      self				:     int							,	a				:     Optional[int]							,	a				:     Optional[Any]							,	a				:     List[str]							,	a				:     str							,	a				:     Union[str, Any]							,	a				:     Optional[Any]							,	a				:     Optional[int]							,	a				:     List[str]							,	a				:     List[str]							,	)	->Dict:
													SCREAMING_SNAKE_CASE__     :				int   =					self.num_labels
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					XLMForTokenClassification(a    )
													model.to(a    )
													model.eval()

													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					model(a							,	attention_mask=a							,	labels=a    )
													self.parent.assertEqual(result.logits.shape							,	(self.batch_size, self.seq_length, self.num_labels)    )

							def      A_  (      self				:     Optional[int]							,	a				:     Dict							,	a				:     int							,	a				:     List[Any]							,	a				:     Optional[Any]							,	a				:     int							,	a				:     Optional[int]							,	a				:     Union[str, Any]							,	a				:     List[Any]							,	a				:     List[Any]							,	)	->str:
													SCREAMING_SNAKE_CASE__     :				int   =					self.num_choices
													SCREAMING_SNAKE_CASE__     :				Dict   =					XLMForMultipleChoice(config=a    )
													model.to(a    )
													model.eval()
													SCREAMING_SNAKE_CASE__     :				str   =					input_ids.unsqueeze(1    ).expand(-1							,	self.num_choices							,	-1    ).contiguous()
													SCREAMING_SNAKE_CASE__     :				Any   =					token_type_ids.unsqueeze(1    ).expand(-1							,	self.num_choices							,	-1    ).contiguous()
													SCREAMING_SNAKE_CASE__     :				str   =					input_mask.unsqueeze(1    ).expand(-1							,	self.num_choices							,	-1    ).contiguous()
													SCREAMING_SNAKE_CASE__     :				Any   =					model(
													    a							,	attention_mask=a							,	token_type_ids=a							,	labels=a							,	)
													self.parent.assertEqual(result.logits.shape							,	(self.batch_size, self.num_choices)    )






							def      A_  (      self				:     List[str]    )	->str:
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					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__
													),							(
													    SCREAMING_SNAKE_CASE__
													),							(
													    SCREAMING_SNAKE_CASE__
													),							
													)     :				str   =					config_and_inputs
													SCREAMING_SNAKE_CASE__     :				int   =					{"input_ids": input_ids, "token_type_ids": token_type_ids, "lengths": input_lengths}
													return config, inputs_dict







@require_torch
class    _a     (				lowercase__					,							lowercase__					,							lowercase__					,							unittest.TestCase							):






							"""simple docstring"""

							snake_case_							 =						(
							    (
							        XLMModel,
							        XLMWithLMHeadModel,
							        XLMForQuestionAnswering,
							        XLMForSequenceClassification,
							        XLMForQuestionAnsweringSimple,
							        XLMForTokenClassification,
							        XLMForMultipleChoice,
							    )
							    if is_torch_available()
							    else ()
							)
							snake_case_							 =						(
							    (XLMWithLMHeadModel,) if is_torch_available() else ()
							)  # TODO (PVP): Check other models whether language generation is also applicable
							snake_case_							 =						(
							    {
							        "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				:     int							,	a				:     List[str]							,	a				:     Union[str, Any]							,	a				:     str							,	a				:     Optional[int]							,	a				:     List[Any]    )	->Tuple:
													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[Any]							,	a				:     Tuple							,	a				:     Tuple							,	a				:     List[str]=False    )	->Union[str, Any]:
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					super()._prepare_for_class(a							,	a							,	return_labels=a    )

													if return_labels:
																			if model_class.__name__ == "XLMForQuestionAnswering":
																									SCREAMING_SNAKE_CASE__     :				str   =					torch.zeros(
																									    self.model_tester.batch_size							,	dtype=torch.long							,	device=a    )
																									SCREAMING_SNAKE_CASE__     :				Dict   =					torch.zeros(
																									    self.model_tester.batch_size							,	dtype=torch.long							,	device=a    )

													return inputs_dict

							def      A_  (      self				:     Optional[Any]    )	->Union[str, Any]:
													SCREAMING_SNAKE_CASE__     :				str   =					XLMModelTester(self    )
													SCREAMING_SNAKE_CASE__     :				int   =					ConfigTester(self							,	config_class=a							,	emb_dim=37    )

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

							def      A_  (      self				:     Any    )	->Tuple:
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_xlm_model(*a    )

							def      A_  (      self				:     Any    )	->List[str]:
													SCREAMING_SNAKE_CASE__     :				Any   =					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_xlm_lm_head(*a    )

							def      A_  (      self				:     List[str]    )	->int:
													SCREAMING_SNAKE_CASE__     :				Dict   =					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_xlm_simple_qa(*a    )

							def      A_  (      self				:     Dict    )	->Optional[Any]:
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_xlm_qa(*a    )

							def      A_  (      self				:     Union[str, Any]    )	->Tuple:
													SCREAMING_SNAKE_CASE__     :				Any   =					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_xlm_sequence_classif(*a    )

							def      A_  (      self				:     int    )	->Any:
													SCREAMING_SNAKE_CASE__     :				int   =					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_xlm_token_classif(*a    )

							def      A_  (      self				:     int    )	->Any:
													SCREAMING_SNAKE_CASE__     :				Dict   =					self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_xlm_for_multiple_choice(*a    )

							def      A_  (      self				:     List[Any]							,	a				:     Tuple							,	a				:     List[Any]							,	a				:     str							,	a				:     str							,	a				:     Union[str, Any]							,	a				:     Optional[int]=False							,	a				:     Dict=1    )	->Union[str, Any]:
													self.assertIsInstance(a							,	a    )
													self.assertListEqual(
													    [isinstance(a							,	a    ) for iter_attentions in attentions]							,	[True] * len(a    )    )
													self.assertEqual(len(a    )							,	(max_length - min_length) * num_beam_groups    )

													for idx, iter_attentions in enumerate(a    ):
																			# adds PAD dummy token
																			SCREAMING_SNAKE_CASE__     :				Tuple   =					min_length + idx + 1
																			SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					min_length + idx + 1

																			SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					(
																			    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(a    )    )

							def      A_  (      self				:     Any							,	a				:     str							,	a				:     Tuple							,	a				:     Any							,	a				:     Any							,	a				:     int							,	a				:     Union[str, Any]=False							,	a				:     str=1    )	->List[str]:
													self.assertIsInstance(a							,	a    )
													self.assertListEqual(
													    [isinstance(a							,	a    ) for iter_hidden_states in hidden_states]							,	[True] * len(a    )							,	)
													self.assertEqual(len(a    )							,	(max_length - min_length) * num_beam_groups    )

													for idx, iter_hidden_states in enumerate(a    ):
																			# adds PAD dummy token
																			SCREAMING_SNAKE_CASE__     :				str   =					min_length + idx + 1
																			SCREAMING_SNAKE_CASE__     :				List[Any]   =					(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(a    )							,	)
													pass






							@slow
							def      A_  (      self				:     Optional[Any]    )	->Any:
													for model_name in XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																			SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					XLMModel.from_pretrained(a    )
																			self.assertIsNotNone(a    )







@require_torch
class    _a     (				unittest.TestCase							):






							"""simple docstring"""

							@slow
							def      A_  (      self				:     List[Any]    )	->Any:
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					XLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048"    )
													model.to(a    )
													SCREAMING_SNAKE_CASE__     :				Dict   =					torch.tensor([[14, 4_47]]							,	dtype=torch.long							,	device=a    )  # the president
													SCREAMING_SNAKE_CASE__     :				int   =					[
													    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
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					model.generate(a							,	do_sample=a    )
													self.assertListEqual(output_ids[0].cpu().numpy().tolist()							,	a    )






import sys

from .dependency_versions_table import deps
from .utils.versions import require_version, require_version_core


# define which module versions we always want to check at run time
# (usually the ones defined in `install_requires` in setup.py)
#
# order specific notes:
# - tqdm must be checked before tokenizers

__lowercase       :List[Any]       =  "python tqdm regex requests packaging filelock numpy tokenizers".split()
if sys.version_info < (3, 7):
				pkgs_to_check_at_runtime.append("dataclasses")
if sys.version_info < (3, 8):
				pkgs_to_check_at_runtime.append("importlib_metadata")

for pkg in pkgs_to_check_at_runtime:
				if pkg in deps:
								if pkg == "tokenizers":
												# must be loaded here, or else tqdm check may fail
												from .utils import is_tokenizers_available

												if not is_tokenizers_available():
																continue  # not required, check version only if installed

								require_version_core(deps[pkg])
				else:
								raise ValueError(f"can't find {pkg} in {deps.keys()}, check dependency_versions_table.py")







def       UpperCAmelCase							(     _lowerCamelCase      :  Optional[Any]			,   _lowerCamelCase      :  Optional[Any]=None     ):





						'''simple docstring'''


						require_version(deps[pkg]			,   _lowerCamelCase     )