
import collections
import inspect
import unittest

from transformers import DonutSwinConfig
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import is_torch_available

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


if is_torch_available():
      import torch
      from torch import nn

      from transformers import DonutSwinModel
      from transformers.models.donut.modeling_donut_swin import DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST





class 							A__		:
      def __init__(				self   ,  __magic_name__   ,  __magic_name__=1_3   ,  __magic_name__=3_2   ,  __magic_name__=2   ,  __magic_name__=3   ,  __magic_name__=1_6   ,  __magic_name__=[1, 2, 1]   ,  __magic_name__=[2, 2, 4]   ,  __magic_name__=2   ,  __magic_name__=2.0   ,  __magic_name__=True   ,  __magic_name__=0.0   ,  __magic_name__=0.0   ,  __magic_name__=0.1   ,  __magic_name__="gelu"   ,  __magic_name__=False   ,  __magic_name__=True   ,  __magic_name__=0.02   ,  __magic_name__=1e-5   ,  __magic_name__=True   ,  __magic_name__=None   ,  __magic_name__=True   ,  __magic_name__=1_0   ,  __magic_name__=8   ,  ):
       lowerCamelCase		:     str          =				parent
       lowerCamelCase		:     int          =				batch_size
       lowerCamelCase		:     str          =				image_size
       lowerCamelCase		:     Tuple          =				patch_size
       lowerCamelCase		:     List[Any]          =				num_channels
       lowerCamelCase		:     int          =				embed_dim
       lowerCamelCase		:     Optional[int]          =				depths
       lowerCamelCase		:     int          =				num_heads
       lowerCamelCase		:     int          =				window_size
       lowerCamelCase		:     Optional[int]          =				mlp_ratio
       lowerCamelCase		:     Tuple          =				qkv_bias
       lowerCamelCase		:     str          =				hidden_dropout_prob
       lowerCamelCase		:     str          =				attention_probs_dropout_prob
       lowerCamelCase		:     List[str]          =				drop_path_rate
       lowerCamelCase		:     Optional[int]          =				hidden_act
       lowerCamelCase		:     Dict          =				use_absolute_embeddings
       lowerCamelCase		:     List[Any]          =				patch_norm
       lowerCamelCase		:     Any          =				layer_norm_eps
       lowerCamelCase		:     Optional[int]          =				initializer_range
       lowerCamelCase		:     Any          =				is_training
       lowerCamelCase		:     str          =				scope
       lowerCamelCase		:     Optional[Any]          =				use_labels
       lowerCamelCase		:     Dict          =				type_sequence_label_size
       lowerCamelCase		:     Any          =				encoder_stride
      def 						UpperCamelCase__							(				self				):
       lowerCamelCase		:     Union[str, Any]          =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

       lowerCamelCase		:     Optional[int]          =				None
       if self.use_labels:
        lowerCamelCase		:     List[str]          =				ids_tensor([self.batch_size]   ,  self.type_sequence_label_size				)

       lowerCamelCase		:     str          =				self.get_config()

       return config, pixel_values, labels
      def 						UpperCamelCase__							(				self				):
       return DonutSwinConfig(
           image_size=self.image_size   ,  patch_size=self.patch_size   ,  num_channels=self.num_channels   ,  embed_dim=self.embed_dim   ,  depths=self.depths   ,  num_heads=self.num_heads   ,  window_size=self.window_size   ,  mlp_ratio=self.mlp_ratio   ,  qkv_bias=self.qkv_bias   ,  hidden_dropout_prob=self.hidden_dropout_prob   ,  attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,  drop_path_rate=self.drop_path_rate   ,  hidden_act=self.hidden_act   ,  use_absolute_embeddings=self.use_absolute_embeddings   ,  path_norm=self.patch_norm   ,  layer_norm_eps=self.layer_norm_eps   ,  initializer_range=self.initializer_range   ,  encoder_stride=self.encoder_stride   ,  )
      def 						UpperCamelCase__							(				self   ,  __magic_name__   ,  __magic_name__   ,  __magic_name__				):
       lowerCamelCase		:     Tuple          =				DonutSwinModel(config=__magic_name__				)
       model.to(__magic_name__				)
       model.eval()
       lowerCamelCase		:     int          =				model(__magic_name__				)

       lowerCamelCase		:     Union[str, Any]          =				((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths				) - 1))
       lowerCamelCase		:     Any          =				int(config.embed_dim * 2 ** (len(config.depths				) - 1)				)

       self.parent.assertEqual(result.last_hidden_state.shape   ,  (self.batch_size, expected_seq_len, expected_dim)				)






      def 						UpperCamelCase__							(				self				):
       lowerCamelCase		:     List[Any]          =				self.prepare_config_and_inputs()
       (
           (
           lowerCamelCase
       )      ,   (
           lowerCamelCase
       )      ,   (
           lowerCamelCase
       )      ,   
       )		:     List[str]          =				config_and_inputs
       lowerCamelCase		:     List[str]          =				{"""pixel_values""": pixel_values}
       return config, inputs_dict





@require_torch
class 							A__		(     __SCREAMING_SNAKE_CASE  ,       __SCREAMING_SNAKE_CASE  ,       unittest.TestCase):
      _UpperCAmelCase    :   Tuple   	=      (DonutSwinModel,) if is_torch_available() else ()
      _UpperCAmelCase    :   str   	=      {"""feature-extraction""": DonutSwinModel} if is_torch_available() else {}
      _UpperCAmelCase    :   List[str]   	=      True

      _UpperCAmelCase    :   Union[str, Any]   	=      False
      _UpperCAmelCase    :   List[Any]   	=      False
      _UpperCAmelCase    :   Dict   	=      False
      def 						UpperCamelCase__							(				self				):
       lowerCamelCase		:     Union[str, Any]          =				DonutSwinModelTester(self				)
       lowerCamelCase		:     int          =				ConfigTester(self   ,  config_class=__magic_name__   ,  embed_dim=3_7				)
      def 						UpperCamelCase__							(				self				):
       self.create_and_test_config_common_properties()
       self.config_tester.create_and_test_config_to_json_string()
       self.config_tester.create_and_test_config_to_json_file()
       self.config_tester.create_and_test_config_from_and_save_pretrained()
       self.config_tester.create_and_test_config_with_num_labels()
       self.config_tester.check_config_can_be_init_without_params()
       self.config_tester.check_config_arguments_init()
      def 						UpperCamelCase__							(				self				):
       return
      def 						UpperCamelCase__							(				self				):
       lowerCamelCase		:     Any          =				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*__magic_name__				)
      def 						UpperCamelCase__							(				self				):
       # DonutSwin does not use inputs_embeds
       pass
      def 						UpperCamelCase__							(				self				):
       lowerCamelCase      ,   lowerCamelCase		:     Dict          =				self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
        lowerCamelCase		:     int          =				model_class(__magic_name__				)
        self.assertIsInstance(model.get_input_embeddings()   ,  (nn.Module)				)
        lowerCamelCase		:     Any          =				model.get_output_embeddings()
        self.assertTrue(x is None or isinstance(__magic_name__   ,  nn.Linear				)				)
      def 						UpperCamelCase__							(				self				):
       lowerCamelCase      ,   lowerCamelCase		:     Dict          =				self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
        lowerCamelCase		:     Union[str, Any]          =				model_class(__magic_name__				)
        lowerCamelCase		:     Tuple          =				inspect.signature(model.forward				)
        # signature.parameters is an OrderedDict => so arg_names order is deterministic
        lowerCamelCase		:     List[Any]          =				[*signature.parameters.keys()]

        lowerCamelCase		:     Any          =				["""pixel_values"""]
        self.assertListEqual(arg_names[:1]   ,  __magic_name__				)
      def 						UpperCamelCase__							(				self				):
       lowerCamelCase      ,   lowerCamelCase		:     Optional[int]          =				self.model_tester.prepare_config_and_inputs_for_common()
       lowerCamelCase		:     int          =				True

       for model_class in self.all_model_classes:
        lowerCamelCase		:     List[str]          =				True
        lowerCamelCase		:     Tuple          =				False
        lowerCamelCase		:     str          =				True
        lowerCamelCase		:     int          =				model_class(__magic_name__				)
        model.to(__magic_name__				)
        model.eval()
        with torch.no_grad():
         lowerCamelCase		:     List[str]          =				model(**self._prepare_for_class(__magic_name__   ,  __magic_name__				)				)
        lowerCamelCase		:     Union[str, Any]          =				outputs.attentions
        lowerCamelCase		:     Optional[int]          =				len(self.model_tester.depths				)
        self.assertEqual(len(__magic_name__				)   ,  __magic_name__				)

        # check that output_attentions also work using config
        del inputs_dict["output_attentions"]
        lowerCamelCase		:     str          =				True
        lowerCamelCase		:     str          =				config.window_size**2
        lowerCamelCase		:     Optional[Any]          =				model_class(__magic_name__				)
        model.to(__magic_name__				)
        model.eval()
        with torch.no_grad():
         lowerCamelCase		:     Union[str, Any]          =				model(**self._prepare_for_class(__magic_name__   ,  __magic_name__				)				)
        lowerCamelCase		:     List[Any]          =				outputs.attentions
        self.assertEqual(len(__magic_name__				)   ,  __magic_name__				)

        self.assertListEqual(
            list(attentions[0].shape[-3:]				)   ,  [self.model_tester.num_heads[0], window_size_squared, window_size_squared]   ,  )
        lowerCamelCase		:     Dict          =				len(__magic_name__				)

        # Check attention is always last and order is fine
        lowerCamelCase		:     Union[str, Any]          =				True
        lowerCamelCase		:     List[str]          =				True
        lowerCamelCase		:     str          =				model_class(__magic_name__				)
        model.to(__magic_name__				)
        model.eval()
        with torch.no_grad():
         lowerCamelCase		:     List[Any]          =				model(**self._prepare_for_class(__magic_name__   ,  __magic_name__				)				)

        if hasattr(self.model_tester   ,  """num_hidden_states_types"""				):
         lowerCamelCase		:     List[str]          =				self.model_tester.num_hidden_states_types
        else:
         # also another +1 for reshaped_hidden_states
         lowerCamelCase		:     Optional[int]          =				2
        self.assertEqual(out_len + added_hidden_states   ,  len(__magic_name__				)				)

        lowerCamelCase		:     List[Any]          =				outputs.attentions

        self.assertEqual(len(__magic_name__				)   ,  __magic_name__				)

        self.assertListEqual(
            list(self_attentions[0].shape[-3:]				)   ,  [self.model_tester.num_heads[0], window_size_squared, window_size_squared]   ,  )
      def 						UpperCamelCase__							(				self   ,  __magic_name__   ,  __magic_name__   ,  __magic_name__   ,  __magic_name__				):
       lowerCamelCase		:     Dict          =				model_class(__magic_name__				)
       model.to(__magic_name__				)
       model.eval()

       with torch.no_grad():
        lowerCamelCase		:     Any          =				model(**self._prepare_for_class(__magic_name__   ,  __magic_name__				)				)

       lowerCamelCase		:     Dict          =				outputs.hidden_states

       lowerCamelCase		:     Optional[Any]          =				getattr(
           self.model_tester   ,  """expected_num_hidden_layers"""   ,  len(self.model_tester.depths				) + 1				)
       self.assertEqual(len(__magic_name__				)   ,  __magic_name__				)

       # DonutSwin has a different seq_length
       lowerCamelCase		:     Union[str, Any]          =				(
           config.patch_size
           if isinstance(config.patch_size   ,  collections.abc.Iterable				)
           else (config.patch_size, config.patch_size)
       )

       lowerCamelCase		:     Any          =				(image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

       self.assertListEqual(
           list(hidden_states[0].shape[-2:]				)   ,  [num_patches, self.model_tester.embed_dim]   ,  )

       lowerCamelCase		:     str          =				outputs.reshaped_hidden_states
       self.assertEqual(len(__magic_name__				)   ,  __magic_name__				)

       lowerCamelCase      ,   lowerCamelCase      ,   lowerCamelCase      ,   lowerCamelCase		:     List[Any]          =				reshaped_hidden_states[0].shape
       lowerCamelCase		:     Optional[int]          =				(
           reshaped_hidden_states[0].view(__magic_name__   ,  __magic_name__   ,  height * width				).permute(0   ,  2   ,  1				)
       )
       self.assertListEqual(
           list(reshaped_hidden_states.shape[-2:]				)   ,  [num_patches, self.model_tester.embed_dim]   ,  )
      def 						UpperCamelCase__							(				self				):
       lowerCamelCase      ,   lowerCamelCase		:     Optional[int]          =				self.model_tester.prepare_config_and_inputs_for_common()

       lowerCamelCase		:     Any          =				(
           self.model_tester.image_size
           if isinstance(self.model_tester.image_size   ,  collections.abc.Iterable				)
           else (self.model_tester.image_size, self.model_tester.image_size)
       )

       for model_class in self.all_model_classes:
        lowerCamelCase		:     str          =				True
        self.check_hidden_states_output(__magic_name__   ,  __magic_name__   ,  __magic_name__   ,  __magic_name__				)

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        lowerCamelCase		:     Dict          =				True

        self.check_hidden_states_output(__magic_name__   ,  __magic_name__   ,  __magic_name__   ,  __magic_name__				)
      def 						UpperCamelCase__							(				self				):
       lowerCamelCase      ,   lowerCamelCase		:     Any          =				self.model_tester.prepare_config_and_inputs_for_common()
       lowerCamelCase		:     List[str]          =				3

       lowerCamelCase		:     Optional[Any]          =				(
           self.model_tester.image_size
           if isinstance(self.model_tester.image_size   ,  collections.abc.Iterable				)
           else (self.model_tester.image_size, self.model_tester.image_size)
       )
       lowerCamelCase		:     Optional[int]          =				(
           config.patch_size
           if isinstance(config.patch_size   ,  collections.abc.Iterable				)
           else (config.patch_size, config.patch_size)
       )

       lowerCamelCase		:     Optional[Any]          =				image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
       lowerCamelCase		:     Union[str, Any]          =				image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

       for model_class in self.all_model_classes:
        lowerCamelCase		:     Dict          =				True
        self.check_hidden_states_output(__magic_name__   ,  __magic_name__   ,  __magic_name__   ,  (padded_height, padded_width)				)

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        lowerCamelCase		:     int          =				True
        self.check_hidden_states_output(__magic_name__   ,  __magic_name__   ,  __magic_name__   ,  (padded_height, padded_width)				)
      @slow
      def 						UpperCamelCase__							(				self				):
       for model_name in DONUT_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        lowerCamelCase		:     List[str]          =				DonutSwinModel.from_pretrained(__magic_name__				)
        self.assertIsNotNone(__magic_name__				)






      def 						UpperCamelCase__							(				self				):
       lowerCamelCase      ,   lowerCamelCase		:     Any          =				self.model_tester.prepare_config_and_inputs_for_common()

       lowerCamelCase		:     Tuple          =				_config_zero_init(__magic_name__				)
       for model_class in self.all_model_classes:
        lowerCamelCase		:     Union[str, Any]          =				model_class(config=__magic_name__				)
        for name, param in model.named_parameters():
         if "embeddings" not in name and param.requires_grad:
          self.assertIn(
              ((param.data.mean() * 1e9).round() / 1e9).item()   ,  [0.0, 1.0]   ,  msg=F'''Parameter {name} of model {model_class} seems not properly initialized'''   ,  )






import unittest

import pytest

from transformers import (
    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    MBartaaTokenizerFast,
    MBartConfig,
    MBartForConditionalGeneration,
    TranslationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, require_tf, require_torch, slow

from .test_pipelines_common import ANY





@is_pipeline_test
class 							A__		(     unittest.TestCase):
      _UpperCAmelCase    :   Tuple   	=      MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
      _UpperCAmelCase    :   Optional[Any]   	=      TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
      def 						UpperCamelCase__							(				self   ,  __magic_name__   ,  __magic_name__   ,  __magic_name__				):
       if isinstance(model.config   ,  __magic_name__				):
        lowerCamelCase      ,   lowerCamelCase		:     Union[str, Any]          =				list(tokenizer.lang_code_to_id.keys()				)[:2]
        lowerCamelCase		:     Tuple          =				TranslationPipeline(model=__magic_name__   ,  tokenizer=__magic_name__   ,  src_lang=__magic_name__   ,  tgt_lang=__magic_name__				)
       else:
        lowerCamelCase		:     Tuple          =				TranslationPipeline(model=__magic_name__   ,  tokenizer=__magic_name__				)
       return translator, ["Some string", "Some other text"]
      def 						UpperCamelCase__							(				self   ,  __magic_name__   ,  __magic_name__				):
       lowerCamelCase		:     Optional[Any]          =				translator("""Some string"""				)
       self.assertEqual(__magic_name__   ,  [{"""translation_text""": ANY(__magic_name__				)}]				)

       lowerCamelCase		:     Dict          =				translator(["""Some string"""]				)
       self.assertEqual(__magic_name__   ,  [{"""translation_text""": ANY(__magic_name__				)}]				)

       lowerCamelCase		:     Any          =				translator(["""Some string""", """other string"""]				)
       self.assertEqual(__magic_name__   ,  [{"""translation_text""": ANY(__magic_name__				)}, {"""translation_text""": ANY(__magic_name__				)}]				)
      @require_torch
      def 						UpperCamelCase__							(				self				):
       lowerCamelCase		:     Any          =				pipeline("""translation_en_to_ro"""   ,  model="""patrickvonplaten/t5-tiny-random"""   ,  framework="""pt"""				)
       lowerCamelCase		:     Union[str, Any]          =				translator("""This is a test string"""   ,  max_length=2_0				)
       self.assertEqual(
           __magic_name__   ,  [
               {
                   """translation_text""": (
                       """Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide"""
                       """ Beide Beide"""
                   )
               }
           ]   ,  )
      @require_tf
      def 						UpperCamelCase__							(				self				):
       lowerCamelCase		:     str          =				pipeline("""translation_en_to_ro"""   ,  model="""patrickvonplaten/t5-tiny-random"""   ,  framework="""tf"""				)
       lowerCamelCase		:     Tuple          =				translator("""This is a test string"""   ,  max_length=2_0				)
       self.assertEqual(
           __magic_name__   ,  [
               {
                   """translation_text""": (
                       """Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide Beide"""
                       """ Beide Beide"""
                   )
               }
           ]   ,  )
      @require_torch
      def 						UpperCamelCase__							(				self				):
       lowerCamelCase		:     int          =				pipeline("""translation_en_to_de"""   ,  model="""patrickvonplaten/t5-tiny-random"""   ,  framework="""pt"""				)
       lowerCamelCase		:     List[Any]          =				translator("""This is a test string"""   ,  max_length=2_0				)
       self.assertEqual(
           __magic_name__   ,  [
               {
                   """translation_text""": (
                       """monoton monoton monoton monoton monoton monoton monoton monoton monoton monoton urine urine"""
                       """ urine urine urine urine urine urine urine"""
                   )
               }
           ]   ,  )






      @require_tf
      def 						UpperCamelCase__							(				self				):
       lowerCamelCase		:     Union[str, Any]          =				pipeline("""translation_en_to_de"""   ,  model="""patrickvonplaten/t5-tiny-random"""   ,  framework="""tf"""				)
       lowerCamelCase		:     Union[str, Any]          =				translator("""This is a test string"""   ,  max_length=2_0				)
       self.assertEqual(
           __magic_name__   ,  [
               {
                   """translation_text""": (
                       """monoton monoton monoton monoton monoton monoton monoton monoton monoton monoton urine urine"""
                       """ urine urine urine urine urine urine urine"""
                   )
               }
           ]   ,  )





class 							A__		(     unittest.TestCase):
      @require_torch
      @slow
      def 						UpperCamelCase__							(				self				):
       # We don't provide a default for this pair
       with self.assertRaises(__magic_name__				):
        pipeline(task="""translation_cn_to_ar"""				)

       # but we do for this one
       lowerCamelCase		:     Optional[Any]          =				pipeline(task="""translation_en_to_de"""				)
       self.assertEqual(translator._preprocess_params["""src_lang"""]   ,  """en"""				)
       self.assertEqual(translator._preprocess_params["""tgt_lang"""]   ,  """de"""				)
      @require_torch
      @slow
      def 						UpperCamelCase__							(				self				):
       lowerCamelCase		:     Optional[int]          =				MBartForConditionalGeneration.from_pretrained("""facebook/mbart-large-50-many-to-many-mmt"""				)
       lowerCamelCase		:     List[Any]          =				MBartaaTokenizerFast.from_pretrained("""facebook/mbart-large-50-many-to-many-mmt"""				)

       lowerCamelCase		:     Any          =				pipeline(task="""translation"""   ,  model=__magic_name__   ,  tokenizer=__magic_name__				)
       # Missing src_lang, tgt_lang
       with self.assertRaises(__magic_name__				):
        translator("""This is a test"""				)

       lowerCamelCase		:     Optional[int]          =				translator("""This is a test"""   ,  src_lang="""en_XX"""   ,  tgt_lang="""ar_AR"""				)
       self.assertEqual(__magic_name__   ,  [{"""translation_text""": """هذا إختبار"""}]				)

       lowerCamelCase		:     Optional[Any]          =				translator("""This is a test"""   ,  src_lang="""en_XX"""   ,  tgt_lang="""hi_IN"""				)
       self.assertEqual(__magic_name__   ,  [{"""translation_text""": """यह एक परीक्षण है"""}]				)

       # src_lang, tgt_lang can be defined at pipeline call time
       lowerCamelCase		:     str          =				pipeline(task="""translation"""   ,  model=__magic_name__   ,  tokenizer=__magic_name__   ,  src_lang="""en_XX"""   ,  tgt_lang="""ar_AR"""				)
       lowerCamelCase		:     Union[str, Any]          =				translator("""This is a test"""				)
       self.assertEqual(__magic_name__   ,  [{"""translation_text""": """هذا إختبار"""}]				)
      @require_torch
      def 						UpperCamelCase__							(				self				):
       lowerCamelCase		:     List[str]          =				"""patrickvonplaten/t5-tiny-random"""
       lowerCamelCase		:     Tuple          =				pipeline(task="""translation_cn_to_ar"""   ,  model=__magic_name__				)
       self.assertEqual(translator._preprocess_params["""src_lang"""]   ,  """cn"""				)
       self.assertEqual(translator._preprocess_params["""tgt_lang"""]   ,  """ar"""				)
      @require_torch
      def 						UpperCamelCase__							(				self				):
       lowerCamelCase		:     Dict          =				"""patrickvonplaten/t5-tiny-random"""
       with pytest.warns(__magic_name__   ,  match=r""".*translation_en_to_de.*"""				):
        lowerCamelCase		:     Optional[int]          =				pipeline(task="""translation"""   ,  model=__magic_name__				)
       self.assertEqual(translator.task   ,  """translation_en_to_de"""				)
       self.assertEqual(translator._preprocess_params["""src_lang"""]   ,  """en"""				)
       self.assertEqual(translator._preprocess_params["""tgt_lang"""]   ,  """de"""				)






      @require_torch
      def 						UpperCamelCase__							(				self				):
       with self.assertRaises(__magic_name__				):
        pipeline(task="""translation"""				)




