code: 
  
  """simple docstring"""
  
  
  
  
  import argparse
  import logging
  import os
  import sys
  import tempfile
  from pathlib import Path
  
  import lightning_base
  import pytest
  import pytorch_lightning as pl
  import torch
  from convert_pl_checkpoint_to_hf import convert_pl_to_hf
  from distillation import distill_main
  from finetune import SummarizationModule, main
  from huggingface_hub import list_models
  from parameterized import parameterized
  from run_eval import generate_summaries_or_translations
  from torch import nn
  
  from transformers import AutoConfig, AutoModelForSeqaSeqLM
  from transformers.testing_utils import CaptureStderr, CaptureStdout, TestCasePlus, require_torch_gpu, slow
  from utils import label_smoothed_nll_loss, lmap, load_json
  
  
  logging.basicConfig(level=logging.DEBUG)
  
  __A  :					Any												=	logging.getLogger()
  __A  :					Dict												=	torch.cuda.is_available()
  __A  :					Optional[Any]												=	{
      'max_tokens_per_batch': None,
      'supervise_forward': True,
      'normalize_hidden': True,
      'label_smoothing': 0.2,
      'eval_max_gen_length': None,
      'eval_beams': 1,
      'val_metric': 'loss',
      'save_top_k': 1,
      'adafactor': True,
      'early_stopping_patience': 2,
      'logger_name': 'default',
      'length_penalty': 0.5,
      'cache_dir': '',
      'task': 'summarization',
      'num_workers': 2,
      'alpha_hid': 0,
      'freeze_embeds': True,
      'enc_only': False,
      'tgt_suffix': '',
      'resume_from_checkpoint': None,
      'sortish_sampler': True,
      'student_decoder_layers': 1,
      'val_check_interval': 1.0,
      'output_dir': '',
      'fp16': False,  # TODO(SS): set this to CUDA_AVAILABLE if ci installs apex or start using native amp
      'no_teacher': False,
      'fp16_opt_level': 'O1',
      'gpus': 1 if CUDA_AVAILABLE else 0,
      'n_tpu_cores': 0,
      'max_grad_norm': 1.0,
      'do_train': True,
      'do_predict': True,
      'accumulate_grad_batches': 1,
      'server_ip': '',
      'server_port': '',
      'seed': 42,
      'model_name_or_path': 'sshleifer/bart-tiny-random',
      'config_name': '',
      'tokenizer_name': 'facebook/bart-large',
      'do_lower_case': False,
      'learning_rate': 0.3,
      'lr_scheduler': 'linear',
      'weight_decay': 0.0,
      'adam_epsilon': 1E-08,
      'warmup_steps': 0,
      'max_epochs': 1,
      'train_batch_size': 2,
      'eval_batch_size': 2,
      'max_source_length': 12,
      'max_target_length': 12,
      'val_max_target_length': 12,
      'test_max_target_length': 12,
      'fast_dev_run': False,
      'no_cache': False,
      'n_train': -1,
      'n_val': -1,
      'n_test': -1,
      'student_encoder_layers': 1,
      'freeze_encoder': False,
      'auto_scale_batch_size': False,
      'overwrite_output_dir': False,
      'student': None,
  }
  def      __SCREAMING_SNAKE_CASE		(		lowercase__    ,							lowercase__   ):
  					"""simple docstring"""
  					A    =      "\n".join(lowercase__   )
  					Path(lowercase__   ).open("w"   ).writelines(lowercase__   )
  
  
  __A  :					Dict												=	[' Sam ate lunch today.', 'Sams lunch ingredients.']
  __A  :					Tuple												=	['A very interesting story about what I ate for lunch.', 'Avocado, celery, turkey, coffee']
  __A  :					List[Any]												=	'patrickvonplaten/t5-tiny-random'
  __A  :					Optional[int]												=	'sshleifer/t5-tinier-random'
  __A  :					int												=	'sshleifer/bart-tiny-random'
  __A  :					Tuple												=	'sshleifer/tiny-mbart'
  __A  :					Dict												=	'sshleifer/tiny-marian-en-de'
  __A  :					List[str]												=	'stas/tiny-wmt19-en-de'
  
  
  __A  :					Optional[int]												=	logging.StreamHandler(sys.stdout)
  logger.addHandler(stream_handler)
  logging.disable(logging.CRITICAL)  # remove noisy download output from tracebacks
  def      __SCREAMING_SNAKE_CASE		(		lowercase__   ):
  					"""simple docstring"""
  					for split in ["train", "val", "test"]:
  										_dump_articles(os.path.join(lowercase__    ,							F"""{split}.source"""   )    ,							lowercase__   )
  										_dump_articles(os.path.join(lowercase__    ,							F"""{split}.target"""   )    ,							lowercase__   )
  					return tmp_dir
  
  
  
  
  
  class     __UpperCamelCase				(     _A		):
  
  
  		@classmethod
  		def       SCREAMING_SNAKE_CASE__     (cls				:	int):
  							logging.disable(logging.CRITICAL)  # remove noisy download output from tracebacks
  							return cls
  
  
  		@slow
  		@require_torch_gpu
  		def       SCREAMING_SNAKE_CASE__     (self				:	Union[str, Any]):
  							A    =      list_models()
  							A    =      "sshleifer"
  							A    =      [x.modelId for x in model_list if x.modelId.startswith(__SCREAMING_SNAKE_CASE)]
  							A    =      ["sshleifer/blenderbot-3B", "sshleifer/blenderbot-90M"]
  							A    =      []
  							for m in model_ids:
  												if m in allowed_to_be_broken:
  																	continue
  												try:
  																	AutoConfig.from_pretrained(__SCREAMING_SNAKE_CASE)
  												except Exception:
  																	failures.append(__SCREAMING_SNAKE_CASE)
  							assert not failures, F"""The following models could not be loaded through AutoConfig: {failures}"""
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Dict):
  							A    =      {"student_encoder_layers": 2, "student_decoder_layers": 1, "no_teacher": True}
  							self._test_distiller_cli(__SCREAMING_SNAKE_CASE)
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Dict):
  							A    =      {
  							    "student_encoder_layers": 2,
  							    "student_decoder_layers": 1,
  							    "max_epochs": 4,
  							    "val_check_interval": 0.2_5,
  							    "alpha_hid": 2.0,
  							    "model_name_or_path": "IGNORE_THIS_IT_DOESNT_GET_USED",
  							}
  							A    =      self._test_distiller_cli(__SCREAMING_SNAKE_CASE  ,  check_contents=__SCREAMING_SNAKE_CASE)
  
  							A    =      list(Path(model.output_dir).glob("*.ckpt"))
  							self.assertEqual(1  ,  len(__SCREAMING_SNAKE_CASE))
  							A    =      list(Path(model.output_dir).glob("**/*.bin"))
  							self.assertEqual(len(__SCREAMING_SNAKE_CASE)  ,  2)
  							A    =      lmap(str.strip  ,  Path(model.hparams.data_dir).joinpath("test.source").open().readlines())
  							A    =      tempfile.mktemp()  # XXX: not being cleaned up
  							generate_summaries_or_translations(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE  ,  str(model.output_dir / "best_tfmr"))
  							self.assertTrue(Path(__SCREAMING_SNAKE_CASE).exists())
  
  							A    =      self.get_auto_remove_tmp_dir()
  							convert_pl_to_hf(ckpts[0]  ,  transformer_ckpts[0].parent  ,  __SCREAMING_SNAKE_CASE)
  							assert os.path.exists(os.path.join(__SCREAMING_SNAKE_CASE  ,  "pytorch_model.bin"))
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Tuple):
  							A    =      AutoModelForSeqaSeqLM.from_pretrained(__SCREAMING_SNAKE_CASE)
  							A    ,					A    =      model.dummy_inputs["input_ids"], model.dummy_inputs["attention_mask"]
  							A    =      torch.tensor([[0, 4, 8, 2], [0, 8, 2, 1]]  ,  dtype=torch.long  ,  device=model.device)
  							A    =      target_ids[:, :-1].contiguous()  # Why this line?
  							A    =      target_ids[:, 1:].clone()  # why clone?
  							A    =      model(
  							    __SCREAMING_SNAKE_CASE  ,  attention_mask=__SCREAMING_SNAKE_CASE  ,  decoder_input_ids=__SCREAMING_SNAKE_CASE  ,  labels=__SCREAMING_SNAKE_CASE  ,  use_cache=__SCREAMING_SNAKE_CASE).loss
  
  							A    =      model(__SCREAMING_SNAKE_CASE  ,  attention_mask=__SCREAMING_SNAKE_CASE  ,  decoder_input_ids=__SCREAMING_SNAKE_CASE  ,  use_cache=__SCREAMING_SNAKE_CASE).logits
  
  							A    =      nn.functional.log_softmax(__SCREAMING_SNAKE_CASE  ,  dim=-1)
  							A    ,					A    =      label_smoothed_nll_loss(
  							    __SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE  ,  0.1  ,  ignore_index=model.config.pad_token_id)
  							with self.assertRaises(__SCREAMING_SNAKE_CASE):
  												# TODO: understand why this breaks
  												self.assertEqual(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE)
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	List[str]):
  							A    =      {
  							    "student_encoder_layers": 2,
  							    "student_decoder_layers": 1,
  							    "num_train_epochs": 4,
  							    "val_check_interval": 0.2_5,
  							    "alpha_hid": 2.0,
  							    "task": "translation",
  							    "model_name_or_path": "IGNORE_THIS_IT_DOESNT_GET_USED",
  							    "tokenizer_name": MBART_TINY,
  							    "teacher": MBART_TINY,
  							    "src_lang": "en_XX",
  							    "tgt_lang": "ro_RO",
  							}
  							A    =      self._test_distiller_cli(__SCREAMING_SNAKE_CASE  ,  check_contents=__SCREAMING_SNAKE_CASE)
  							assert model.model.config.model_type == "mbart"
  
  							A    =      list(Path(model.output_dir).glob("*.ckpt"))
  							self.assertEqual(1  ,  len(__SCREAMING_SNAKE_CASE))
  							A    =      list(Path(model.output_dir).glob("**/*.bin"))
  							A    =      list(Path(model.output_dir).glob("best_tfmr/*"))
  							assert len(__SCREAMING_SNAKE_CASE) > 2
  							self.assertEqual(len(__SCREAMING_SNAKE_CASE)  ,  2)
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Optional[int]):
  							A    =      {
  							    "student_encoder_layers": 1,
  							    "student_decoder_layers": 1,
  							    "alpha_hid": 2.0,
  							    "teacher": T5_TINY,
  							    "model_name_or_path": T5_TINY,
  							    "tokenizer_name": T5_TINY,
  							}
  							self._test_distiller_cli(__SCREAMING_SNAKE_CASE)
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Dict):
  							A    =      {
  							    "teacher": T5_TINY,
  							    "student": T5_TINIER,
  							    "model_name_or_path": T5_TINIER,
  							    "tokenizer_name": T5_TINIER,
  							}
  							self._test_distiller_cli(__SCREAMING_SNAKE_CASE)
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Tuple  ,  __SCREAMING_SNAKE_CASE				:	List[Any]  ,  __SCREAMING_SNAKE_CASE				:	List[Any]=True):
  							A    =      {
  							    "label_smoothing": 0.0,
  							    "early_stopping_patience": -1,
  							    "train_batch_size": 1,
  							    "eval_batch_size": 2,
  							    "max_epochs": 2,
  							    "alpha_mlm": 0.2,
  							    "alpha_ce": 0.8,
  							    "do_predict": True,
  							    "model_name_or_path": "sshleifer/tinier_bart",
  							    "teacher": CHEAP_ARGS["model_name_or_path"],
  							    "val_check_interval": 0.5,
  							}
  							default_updates.update(__SCREAMING_SNAKE_CASE)
  							A    =      CHEAP_ARGS.copy()
  							A    =      make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir())
  							A    =      self.get_auto_remove_tmp_dir()
  
  							args_d.update(data_dir=__SCREAMING_SNAKE_CASE  ,  output_dir=__SCREAMING_SNAKE_CASE  ,  **__SCREAMING_SNAKE_CASE)
  							A    =      distill_main(argparse.Namespace(**__SCREAMING_SNAKE_CASE))
  							if not check_contents:
  												return model
  							A    =      os.listdir(__SCREAMING_SNAKE_CASE)
  							A    =      {os.path.basename(__SCREAMING_SNAKE_CASE) for p in contents}
  							A    =      [p for p in contents if p.endswith("ckpt")]
  							assert len(__SCREAMING_SNAKE_CASE) > 0
  
  							self.assertIn("test_generations.txt"  ,  __SCREAMING_SNAKE_CASE)
  							self.assertIn("test_results.txt"  ,  __SCREAMING_SNAKE_CASE)
  
  							A    =      load_json(model.metrics_save_path)
  							A    =      metrics["val"][-1]
  							self.assertGreaterEqual(last_step_stats["val_avg_gen_time"]  ,  0.0_1)
  							self.assertGreaterEqual(1.0  ,  last_step_stats["val_avg_gen_time"])
  							self.assertIsInstance(last_step_stats[F"""val_avg_{model.val_metric}"""]  ,  __SCREAMING_SNAKE_CASE)
  							A    =      int(args_d["max_epochs"] * (1 / args_d["val_check_interval"]) + 1)
  							self.assertEqual(len(metrics["val"])  ,  __SCREAMING_SNAKE_CASE)
  							self.assertEqual(len(metrics["test"])  ,  1)
  							return model
  
  
  
  
  
  class     __UpperCamelCase				(     _A		):
  
  
  		@parameterized.expand(
  		    [T5_TINY, BART_TINY, MBART_TINY, MARIAN_TINY, FSMT_TINY]  ,  )
  		def       SCREAMING_SNAKE_CASE__     (self				:	Tuple  ,  __SCREAMING_SNAKE_CASE				:	Union[str, Any]):
  							A    =      CHEAP_ARGS.copy()
  							A    =      "translation" if model in [MBART_TINY, MARIAN_TINY, FSMT_TINY] else "summarization"
  							A    =      0.1 if task == "translation" else 0
  
  							A    =      make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir())
  							A    =      self.get_auto_remove_tmp_dir()
  							args_d.update(
  							    data_dir=__SCREAMING_SNAKE_CASE  ,  model_name_or_path=__SCREAMING_SNAKE_CASE  ,  tokenizer_name=__SCREAMING_SNAKE_CASE  ,  train_batch_size=2  ,  eval_batch_size=2  ,  output_dir=__SCREAMING_SNAKE_CASE  ,  do_predict=__SCREAMING_SNAKE_CASE  ,  task=__SCREAMING_SNAKE_CASE  ,  src_lang="en_XX"  ,  tgt_lang="ro_RO"  ,  freeze_encoder=__SCREAMING_SNAKE_CASE  ,  freeze_embeds=__SCREAMING_SNAKE_CASE  ,  )
  							assert "n_train" in args_d
  							A    =      argparse.Namespace(**__SCREAMING_SNAKE_CASE)
  							A    =      main(__SCREAMING_SNAKE_CASE)
  
  							A    =      module.model.get_input_embeddings()
  							assert not input_embeds.weight.requires_grad
  							if model == T5_TINY:
  												A    =      module.model.lm_head
  												assert not lm_head.weight.requires_grad
  												assert (lm_head.weight == input_embeds.weight).all().item()
  							elif model == FSMT_TINY:
  												A    =      module.model.model
  												A    =      fsmt.decoder.embed_positions
  												assert not embed_pos.weight.requires_grad
  												assert not fsmt.decoder.embed_tokens.weight.requires_grad
  												# check that embeds are not the same
  												assert fsmt.decoder.embed_tokens != fsmt.encoder.embed_tokens
  							else:
  												A    =      module.model.model
  												A    =      bart.decoder.embed_positions
  												assert not embed_pos.weight.requires_grad
  												assert not bart.shared.weight.requires_grad
  												# check that embeds are the same
  												assert bart.decoder.embed_tokens == bart.encoder.embed_tokens
  												assert bart.decoder.embed_tokens == bart.shared
  
  							A    =      load_json(module.output_dir / "text_batch.json")
  							assert isinstance(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE)
  							assert len(__SCREAMING_SNAKE_CASE) >= 4
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Any):
  							A    =      CHEAP_ARGS.copy()
  
  							A    =      "summarization"
  							A    =      make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir())
  
  							args_d.update(
  							    data_dir=__SCREAMING_SNAKE_CASE  ,  tokenizer_name=__SCREAMING_SNAKE_CASE  ,  train_batch_size=2  ,  eval_batch_size=2  ,  do_predict=__SCREAMING_SNAKE_CASE  ,  task=__SCREAMING_SNAKE_CASE  ,  src_lang="en_XX"  ,  tgt_lang="ro_RO"  ,  freeze_encoder=__SCREAMING_SNAKE_CASE  ,  freeze_embeds=__SCREAMING_SNAKE_CASE  ,  )
  
  							# test models whose config includes the extra_model_args
  							A    =      BART_TINY
  							A    =      self.get_auto_remove_tmp_dir()
  							A    =      args_d.copy()
  							args_da.update(
  							    model_name_or_path=__SCREAMING_SNAKE_CASE  ,  output_dir=__SCREAMING_SNAKE_CASE  ,  )
  							A    =      ("encoder_layerdrop", "decoder_layerdrop", "dropout", "attention_dropout")
  							for p in extra_model_params:
  												A    =      0.5
  							A    =      argparse.Namespace(**__SCREAMING_SNAKE_CASE)
  							A    =      main(__SCREAMING_SNAKE_CASE)
  							for p in extra_model_params:
  												assert getattr(model.config  ,  __SCREAMING_SNAKE_CASE) == 0.5, F"""failed to override the model config for param {p}"""
  
  							# test models whose config doesn't include the extra_model_args
  							A    =      T5_TINY
  							A    =      self.get_auto_remove_tmp_dir()
  							A    =      args_d.copy()
  							args_da.update(
  							    model_name_or_path=__SCREAMING_SNAKE_CASE  ,  output_dir=__SCREAMING_SNAKE_CASE  ,  )
  							A    =      "encoder_layerdrop"
  							A    =      0.5
  							A    =      argparse.Namespace(**__SCREAMING_SNAKE_CASE)
  							with pytest.raises(__SCREAMING_SNAKE_CASE) as excinfo:
  												A    =      main(__SCREAMING_SNAKE_CASE)
  							assert str(excinfo.value) == F"""model config doesn't have a `{unsupported_param}` attribute"""
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Dict):
  							A    =      CHEAP_ARGS.copy()
  
  							A    =      "summarization"
  							A    =      make_test_data_dir(tmp_dir=self.get_auto_remove_tmp_dir())
  
  							A    =      BART_TINY
  							A    =      self.get_auto_remove_tmp_dir()
  
  							args_d.update(
  							    data_dir=__SCREAMING_SNAKE_CASE  ,  model_name_or_path=__SCREAMING_SNAKE_CASE  ,  output_dir=__SCREAMING_SNAKE_CASE  ,  tokenizer_name=__SCREAMING_SNAKE_CASE  ,  train_batch_size=2  ,  eval_batch_size=2  ,  do_predict=__SCREAMING_SNAKE_CASE  ,  task=__SCREAMING_SNAKE_CASE  ,  src_lang="en_XX"  ,  tgt_lang="ro_RO"  ,  freeze_encoder=__SCREAMING_SNAKE_CASE  ,  freeze_embeds=__SCREAMING_SNAKE_CASE  ,  )
  
  							# emulate finetune.py
  							A    =      argparse.ArgumentParser()
  							A    =      pl.Trainer.add_argparse_args(__SCREAMING_SNAKE_CASE)
  							A    =      SummarizationModule.add_model_specific_args(__SCREAMING_SNAKE_CASE  ,  os.getcwd())
  							A    =      {"--help": True}
  
  							# --help test
  							with pytest.raises(__SCREAMING_SNAKE_CASE) as excinfo:
  												with CaptureStdout() as cs:
  																	A    =      parser.parse_args(__SCREAMING_SNAKE_CASE)
  												assert False, "--help is expected to sys.exit"
  							assert excinfo.type == SystemExit
  							A    =      lightning_base.arg_to_scheduler_metavar
  							assert expected in cs.out, "--help is expected to list the supported schedulers"
  
  							# --lr_scheduler=non_existing_scheduler test
  							A    =      "non_existing_scheduler"
  							A    =      {F"""--lr_scheduler={unsupported_param}"""}
  							with pytest.raises(__SCREAMING_SNAKE_CASE) as excinfo:
  												with CaptureStderr() as cs:
  																	A    =      parser.parse_args(__SCREAMING_SNAKE_CASE)
  												assert False, "invalid argument is expected to sys.exit"
  							assert excinfo.type == SystemExit
  							A    =      F"""invalid choice: '{unsupported_param}'"""
  							assert expected in cs.err, F"""should have bailed on invalid choice of scheduler {unsupported_param}"""
  
  							# --lr_scheduler=existing_scheduler test
  							A    =      "cosine"
  							A    =      args_d.copy()
  							A    =      supported_param
  							A    =      argparse.Namespace(**__SCREAMING_SNAKE_CASE)
  							A    =      main(__SCREAMING_SNAKE_CASE)
  							assert (
  							    getattr(model.hparams  ,  "lr_scheduler") == supported_param
  							), F"""lr_scheduler={supported_param} shouldn't fail"""
  
  
  
  
  
  
  
style_context: 
  
  """simple docstring"""
  
  
  
  
  import os
  
  from ...utils import logging
  from .utils import DataProcessor, InputExample
  
  
  __A  :					List[Any]												=	logging.get_logger(__name__)
  
  
  
  
  
  class     __UpperCamelCase				(     _A		):
  
  
  		def __init__(self				:	Dict  ,  __SCREAMING_SNAKE_CASE				:	int  ,  __SCREAMING_SNAKE_CASE				:	Any=None):
  							A    =      language
  							A    =      train_language
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	Tuple  ,  __SCREAMING_SNAKE_CASE				:	Tuple):
  							A    =      self.language if self.train_language is None else self.train_language
  							A    =      self._read_tsv(os.path.join(__SCREAMING_SNAKE_CASE  ,  F"""XNLI-MT-1.0/multinli/multinli.train.{lg}.tsv"""))
  							A    =      []
  							for i, line in enumerate(__SCREAMING_SNAKE_CASE):
  												if i == 0:
  																	continue
  												A    =      F"""train-{i}"""
  												A    =      line[0]
  												A    =      line[1]
  												A    =      "contradiction" if line[2] == "contradictory" else line[2]
  												if not isinstance(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE):
  																	raise ValueError(F"""Training input {text_a} is not a string""")
  												if not isinstance(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE):
  																	raise ValueError(F"""Training input {text_b} is not a string""")
  												if not isinstance(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE):
  																	raise ValueError(F"""Training label {label} is not a string""")
  												examples.append(InputExample(guid=__SCREAMING_SNAKE_CASE  ,  text_a=__SCREAMING_SNAKE_CASE  ,  text_b=__SCREAMING_SNAKE_CASE  ,  label=__SCREAMING_SNAKE_CASE))
  							return examples
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	List[str]  ,  __SCREAMING_SNAKE_CASE				:	Tuple):
  							A    =      self._read_tsv(os.path.join(__SCREAMING_SNAKE_CASE  ,  "XNLI-1.0/xnli.test.tsv"))
  							A    =      []
  							for i, line in enumerate(__SCREAMING_SNAKE_CASE):
  												if i == 0:
  																	continue
  												A    =      line[0]
  												if language != self.language:
  																	continue
  												A    =      F"""test-{i}"""
  												A    =      line[6]
  												A    =      line[7]
  												A    =      line[1]
  												if not isinstance(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE):
  																	raise ValueError(F"""Training input {text_a} is not a string""")
  												if not isinstance(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE):
  																	raise ValueError(F"""Training input {text_b} is not a string""")
  												if not isinstance(__SCREAMING_SNAKE_CASE  ,  __SCREAMING_SNAKE_CASE):
  																	raise ValueError(F"""Training label {label} is not a string""")
  												examples.append(InputExample(guid=__SCREAMING_SNAKE_CASE  ,  text_a=__SCREAMING_SNAKE_CASE  ,  text_b=__SCREAMING_SNAKE_CASE  ,  label=__SCREAMING_SNAKE_CASE))
  							return examples
  
  
  		def       SCREAMING_SNAKE_CASE__     (self				:	str):
  							return ["contradiction", "entailment", "neutral"]
  
  __A  :					Optional[int]												=	{
      'xnli': XnliProcessor,
  }
  
  __A  :					Union[str, Any]												=	{
      'xnli': 'classification',
  }
  
  __A  :					Tuple												=	{
      'xnli': 3,
  }
  
  
  
  
  
  