
import unittest

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


if is_torch_available():
  import torch

  from transformers import XLMProphetNetForConditionalGeneration, XLMProphetNetTokenizer

@require_torch
class __snake_case	(   unittest.TestCase  ):
    @slow
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           lowercase							:  int 			=   XLMProphetNetForConditionalGeneration.from_pretrained("""microsoft/xprophetnet-large-wiki100-cased"""   )
           model.to(snake_case   )

           # encoder-decoder outputs
           lowercase							:  List[str] 			=   torch.tensor([[17, 96208, 103471, 2]]   ).to(snake_case   )
           lowercase							:  List[str] 			=   torch.tensor(
               [[2, 250, 9953, 34, 69489, 1620, 32, 118424, 624, 210, 105, 2913, 1032, 351]]   ).to(snake_case   )
           lowercase							:  str 			=   model(
               input_ids=snake_case	,attention_mask=snake_case	,encoder_outputs=snake_case	,decoder_input_ids=snake_case   )
           lowercase							:  Tuple 			=   output[0]
           lowercase							:  int 			=   torch.Size((1, 14, 250012)   )
           self.assertEqual(output_predited_logis.shape	,snake_case   )
           lowercase							:  Union[str, Any] 			=   torch.tensor(
               [[[-6.3_986, -8.2_391, 12.5_189], [-6.3_289, -8.0_864, 12.6_211], [-6.2_418, -8.0_445, 12.7_968]]]   ).to(snake_case   )
           self.assertTrue(torch.allclose(output_predited_logis[:, :3, :3]	,snake_case	,atol=1e-4   )   )

           # encoder outputs
           lowercase							:  Tuple 			=   model.prophetnet.encoder(snake_case   )[0]
           lowercase							:  Any 			=   torch.tensor(
               [[[-1.4_260, -0.7_628, 0.8_453], [-1.4_719, -0.1_391, 0.7_807], [-1.7_678, 0.0_114, 0.4_646]]]   ).to(snake_case   )
           lowercase							:  Optional[Any] 			=   torch.Size((1, 4, 1024)   )
           self.assertEqual(encoder_outputs.shape	,snake_case   )
           self.assertTrue(torch.allclose(encoder_outputs[:, :3, :3]	,snake_case	,atol=1e-4   )   )

           # decoder outputs
           lowercase							:  Tuple 			=   model.prophetnet.decoder(
               snake_case	,encoder_hidden_states=snake_case	,)
           lowercase							:  Optional[int] 			=   decoder_outputs[1].view(1	,model.config.ngram	,14	,-1   )
           lowercase							:  Optional[int] 			=   model.lm_head(snake_case   )
           lowercase							:  List[Any] 			=   predicting_streams_logits[:, 0]
           self.assertTrue(torch.allclose(next_first_stream_logits[:, :3, :3]	,snake_case	,atol=1e-4   )   )
    @slow
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           lowercase							:  Optional[Any] 			=   XLMProphetNetForConditionalGeneration.from_pretrained(
               """microsoft/xprophetnet-large-wiki100-cased-xglue-ntg"""   )
           model.to(snake_case   )

           lowercase							:  Optional[int] 			=   torch.tensor([[17, 96208, 103471, 2]]   ).to(snake_case   )
           lowercase							:  Dict 			=   torch.tensor(
               [[2, 250, 9953, 34, 69489, 1620, 32, 118424, 624, 210, 105, 2913, 1032, 351]]   ).to(snake_case   )
           lowercase							:  Any 			=   model(
               input_ids=snake_case	,attention_mask=snake_case	,encoder_outputs=snake_case	,decoder_input_ids=snake_case   )
           lowercase							:  Optional[int] 			=   output[0]
           lowercase							:  Dict 			=   torch.Size((1, 14, 250012)   )
           self.assertEqual(output_predited_logis.shape	,snake_case   )
           # compare the actual values for a slice.
           lowercase							:  int 			=   torch.tensor(
               [[[-9.2_253, -9.7_173, -6.3_529], [-7.6_701, -9.0_145, -1.9_382], [-8.0_195, -7.0_004, -0.1_523]]]   ).to(snake_case   )

           self.assertTrue(torch.allclose(output_predited_logis[:, :3, :3]	,snake_case	,atol=1e-4   )   )
    @slow
    def    _SCREAMING_SNAKE_CASE (						self   ):



           '''simple docstring'''







           lowercase							:  Any 			=   XLMProphetNetForConditionalGeneration.from_pretrained(
               """microsoft/xprophetnet-large-wiki100-cased-xglue-ntg"""   )
           model.to(snake_case   )
           lowercase							:  Optional[int] 			=   512

           lowercase							:  List[Any] 			=   XLMProphetNetTokenizer.from_pretrained("""microsoft/xprophetnet-large-wiki100-cased-xglue-ntg"""   )

           lowercase							:  int 			=   (
               """Microsoft Corporation intends to officially end free support for the Windows 7 operating system after"""
               """ January 14, 2020, according to the official portal of the organization. From that day, users of this"""
               """ system will not be able to receive security updates, which could make their computers vulnerable to"""
               """ cyber attacks."""
           )
           lowercase							:  List[str] 			=   (
               """орпорация Microsoft намерена официально прекратить бесплатную поддержку операционной системы Windows 7"""
               """ после 14 января 2020 года, сообщается на официальном портале организации . С указанного дня пользователи"""
               """ этой системы не смогут получать обновления безопасности, из-за чего их компьютеры могут стать уязвимыми"""
               """ к кибератакам."""
           )
           lowercase							:  str 			=   (
               """根据该组织的官方门户网站，微软公司打算在2020年1月14日之后正式终止对Windows 7操作系统的免费支持。从那时起，该系统的用户将无法接收安全更新，这可能会使他们的计算机容易受到网络攻击。"""
           )

           lowercase							:  Tuple 			=   tokenizer(
               [EN_SENTENCE, RU_SENTENCE, ZH_SENTENCE]	,padding=snake_case	,max_length=255	,return_tensors="""pt"""   ).input_ids
           lowercase							:  Union[str, Any] 			=   input_ids.to(snake_case   )

           lowercase							:  Dict 			=   model.generate(
               snake_case	,num_beams=10	,length_penalty=1.0	,no_repeat_ngram_size=3	,early_stopping=snake_case   )
           lowercase							:  Any 			=   [tokenizer.decode(snake_case	,skip_special_tokens=snake_case   ) for g in summary_ids]
           lowercase							:  Union[str, Any] 			=   """Microsoft to end Windows 7 free support after January 14, 2020"""
           lowercase							:  Tuple 			=   """Microsoft намерена прекратить бесплатную поддержку Windows 7 после 14 января 2020 года"""
           lowercase							:  Dict 			=   """微软打算终止对Windows 7操作系统的免费支持"""
           self.assertListEqual(
               [EXPECTED_TITLE_EN, EXPECTED_TITLE_RU, EXPECTED_TITLE_ZH]	,snake_case	,)

           lowercase							:  int 			=   model.generate(
               snake_case	,num_beams=1	,length_penalty=1.0	,no_repeat_ngram_size=3	,early_stopping=snake_case   )
           lowercase							:  List[Any] 			=   [
               tokenizer.convert_ids_to_tokens(snake_case	,skip_special_tokens=snake_case   ) for g in summary_ids_beama
           ]
           lowercase							:  List[str] 			=   """▁Microsoft ▁to ▁end ▁free ▁support ▁for ▁Windows ▁7""".split(""" """   )
           lowercase							:  Optional[Any] 			=   """▁Microsoft ▁намерен а ▁прекрати ть ▁бес плат ную ▁поддержку ▁Windows ▁7 ▁после ▁14 ▁января ▁2020 ▁года""".split(
               """ """   )
           lowercase							:  Optional[Any] 			=   """微软 公司 打算 终止 对 Windows ▁7 操作 系统的 免费 支持""".split(""" """   )
           self.assertListEqual(
               [EXPECTED_TITLE_EN_BEAM1_TOK, EXPECTED_TITLE_RU_BEAM1_TOK, EXPECTED_TITLE_ZH_BEAM1_TOK]	,snake_case	,)


import importlib
import inspect
import json
import os
from collections import OrderedDict

# Build the list of all feature extractors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...feature_extraction_utils import FeatureExtractionMixin
from ...image_processing_utils import ImageProcessingMixin
from ...tokenization_utils import TOKENIZER_CONFIG_FILE
from ...utils import FEATURE_EXTRACTOR_NAME, get_file_from_repo, logging
from .auto_factory import _LazyAutoMapping
from .configuration_auto import (
    CONFIG_MAPPING_NAMES,
    AutoConfig,
    model_type_to_module_name,
    replace_list_option_in_docstrings,
)
from .feature_extraction_auto import AutoFeatureExtractor
from .image_processing_auto import AutoImageProcessor
from .tokenization_auto import AutoTokenizer


lowercase						:      Tuple							=							logging.get_logger(__name__)

lowercase						:      Optional[int]							=							OrderedDict(
    [
        ("""align""", """AlignProcessor"""),
        ("""altclip""", """AltCLIPProcessor"""),
        ("""bark""", """BarkProcessor"""),
        ("""blip""", """BlipProcessor"""),
        ("""blip-2""", """Blip2Processor"""),
        ("""bridgetower""", """BridgeTowerProcessor"""),
        ("""chinese_clip""", """ChineseCLIPProcessor"""),
        ("""clap""", """ClapProcessor"""),
        ("""clip""", """CLIPProcessor"""),
        ("""clipseg""", """CLIPSegProcessor"""),
        ("""flava""", """FlavaProcessor"""),
        ("""git""", """GitProcessor"""),
        ("""groupvit""", """CLIPProcessor"""),
        ("""hubert""", """Wav2Vec2Processor"""),
        ("""instructblip""", """InstructBlipProcessor"""),
        ("""layoutlmv2""", """LayoutLMv2Processor"""),
        ("""layoutlmv3""", """LayoutLMv3Processor"""),
        ("""markuplm""", """MarkupLMProcessor"""),
        ("""mctct""", """MCTCTProcessor"""),
        ("""mgp-str""", """MgpstrProcessor"""),
        ("""oneformer""", """OneFormerProcessor"""),
        ("""owlvit""", """OwlViTProcessor"""),
        ("""pix2struct""", """Pix2StructProcessor"""),
        ("""sam""", """SamProcessor"""),
        ("""sew""", """Wav2Vec2Processor"""),
        ("""sew-d""", """Wav2Vec2Processor"""),
        ("""speech_to_text""", """Speech2TextProcessor"""),
        ("""speech_to_text_2""", """Speech2Text2Processor"""),
        ("""speecht5""", """SpeechT5Processor"""),
        ("""trocr""", """TrOCRProcessor"""),
        ("""tvlt""", """TvltProcessor"""),
        ("""unispeech""", """Wav2Vec2Processor"""),
        ("""unispeech-sat""", """Wav2Vec2Processor"""),
        ("""vilt""", """ViltProcessor"""),
        ("""vision-text-dual-encoder""", """VisionTextDualEncoderProcessor"""),
        ("""wav2vec2""", """Wav2Vec2Processor"""),
        ("""wav2vec2-conformer""", """Wav2Vec2Processor"""),
        ("""wavlm""", """Wav2Vec2Processor"""),
        ("""whisper""", """WhisperProcessor"""),
        ("""xclip""", """XCLIPProcessor"""),
    ]
)

lowercase						:      str							=							_LazyAutoMapping(CONFIG_MAPPING_NAMES, PROCESSOR_MAPPING_NAMES)







def 		_snake_case(						SCREAMING_SNAKE_CASE__       )				->					List[Any]:
       for module_name, processors in PROCESSOR_MAPPING_NAMES.items():
              if class_name in processors:
                     lowercase							:  Optional[int] 			=   model_type_to_module_name(SCREAMING_SNAKE_CASE__       )

                     lowercase							:  str 			=   importlib.import_module(f".{module_name}"      ,			"""transformers.models"""       )
                     try:
                            return getattr(SCREAMING_SNAKE_CASE__      ,			SCREAMING_SNAKE_CASE__       )
                     except AttributeError:
                            continue

       for processor in PROCESSOR_MAPPING._extra_content.values():
              if getattr(SCREAMING_SNAKE_CASE__      ,			"""__name__"""      ,			SCREAMING_SNAKE_CASE__       ) == class_name:
                     return processor

    # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main
    # init and we return the proper dummy to get an appropriate error message.
       lowercase							:  Dict 			=   importlib.import_module("""transformers"""       )
       if hasattr(SCREAMING_SNAKE_CASE__      ,			SCREAMING_SNAKE_CASE__       ):
              return getattr(SCREAMING_SNAKE_CASE__      ,			SCREAMING_SNAKE_CASE__       )

       return None




class __snake_case	:
    def __init__(						self   ):



           '''simple docstring'''







           raise EnvironmentError(
               """AutoProcessor is designed to be instantiated """
               """using the `AutoProcessor.from_pretrained(pretrained_model_name_or_path)` method."""   )
    @classmethod
    @replace_list_option_in_docstrings(snake_case   )
    def    _SCREAMING_SNAKE_CASE (						cls	,snake_case	,**snake_case   ):



           '''simple docstring'''







           lowercase							:  Any 			=   kwargs.pop("""config"""	,snake_case   )
           lowercase							:  Optional[int] 			=   kwargs.pop("""trust_remote_code"""	,snake_case   )
           lowercase							:  Union[str, Any] 			=   True

           lowercase							:  Optional[Any] 			=   None
           lowercase							:  Optional[Any] 			=   None

           # First, let's see if we have a preprocessor config.
           # Filter the kwargs for `get_file_from_repo`.
           lowercase							:  str 			=   {
               key: kwargs[key] for key in inspect.signature(snake_case   ).parameters.keys() if key in kwargs
           }
           # Let's start by checking whether the processor class is saved in an image processor
           lowercase							:  Dict 			=   get_file_from_repo(
               snake_case	,snake_case	,**snake_case   )
           if preprocessor_config_file is not None:
                  lowercase			,    lowercase							:  Dict 			=   ImageProcessingMixin.get_image_processor_dict(snake_case	,**snake_case   )
                  lowercase							:  Dict 			=   config_dict.get("""processor_class"""	,snake_case   )
                  if "AutoProcessor" in config_dict.get("""auto_map"""	,{}   ):
                         lowercase							:  List[str] 			=   config_dict["""auto_map"""]["""AutoProcessor"""]

        # If not found, let's check whether the processor class is saved in a feature extractor config
           if preprocessor_config_file is not None and processor_class is None:
                  lowercase			,    lowercase							:  Dict 			=   FeatureExtractionMixin.get_feature_extractor_dict(snake_case	,**snake_case   )
                  lowercase							:  Dict 			=   config_dict.get("""processor_class"""	,snake_case   )
                  if "AutoProcessor" in config_dict.get("""auto_map"""	,{}   ):
                         lowercase							:  Any 			=   config_dict["""auto_map"""]["""AutoProcessor"""]

           if processor_class is None:
                  # Next, let's check whether the processor class is saved in a tokenizer
                  lowercase							:  Any 			=   get_file_from_repo(
                      snake_case	,snake_case	,**snake_case   )
                  if tokenizer_config_file is not None:
                         with open(snake_case	,encoding="""utf-8"""   ) as reader:
                                lowercase							:  Optional[int] 			=   json.load(snake_case   )

                         lowercase							:  Union[str, Any] 			=   config_dict.get("""processor_class"""	,snake_case   )
                         if "AutoProcessor" in config_dict.get("""auto_map"""	,{}   ):
                                lowercase							:  Optional[Any] 			=   config_dict["""auto_map"""]["""AutoProcessor"""]

           if processor_class is None:
                  # Otherwise, load config, if it can be loaded.
                  if not isinstance(snake_case	,snake_case   ):
                         lowercase							:  Union[str, Any] 			=   AutoConfig.from_pretrained(
                             snake_case	,trust_remote_code=snake_case	,**snake_case   )

                  # And check if the config contains the processor class.
                  lowercase							:  str 			=   getattr(snake_case	,"""processor_class"""	,snake_case   )
                  if hasattr(snake_case	,"""auto_map"""   ) and "AutoProcessor" in config.auto_map:
                         lowercase							:  Tuple 			=   config.auto_map["""AutoProcessor"""]

           if processor_class is not None:
                  lowercase							:  List[str] 			=   processor_class_from_name(snake_case   )

           lowercase							:  str 			=   processor_auto_map is not None
           lowercase							:  str 			=   processor_class is not None or type(snake_case   ) in PROCESSOR_MAPPING
           lowercase							:  List[Any] 			=   resolve_trust_remote_code(
               snake_case	,snake_case	,snake_case	,snake_case   )

           if has_remote_code and trust_remote_code:
                  lowercase							:  Dict 			=   get_class_from_dynamic_module(
                      snake_case	,snake_case	,**snake_case   )
                  lowercase							:  str 			=   kwargs.pop("""code_revision"""	,snake_case   )
                  if os.path.isdir(snake_case   ):
                         processor_class.register_for_auto_class()
                  return processor_class.from_pretrained(
                      snake_case	,trust_remote_code=snake_case	,**snake_case   )
           elif processor_class is not None:
                  return processor_class.from_pretrained(
                      snake_case	,trust_remote_code=snake_case	,**snake_case   )
           # Last try: we use the PROCESSOR_MAPPING.
           elif type(snake_case   ) in PROCESSOR_MAPPING:
                  return PROCESSOR_MAPPING[type(snake_case   )].from_pretrained(snake_case	,**snake_case   )

           # At this stage, there doesn't seem to be a `Processor` class available for this model, so let's try a
           # tokenizer.
           try:
                  return AutoTokenizer.from_pretrained(
                      snake_case	,trust_remote_code=snake_case	,**snake_case   )
           except Exception:
                  try:
                         return AutoImageProcessor.from_pretrained(
                             snake_case	,trust_remote_code=snake_case	,**snake_case   )
                  except Exception:
                         pass

                  try:
                         return AutoFeatureExtractor.from_pretrained(
                             snake_case	,trust_remote_code=snake_case	,**snake_case   )
                  except Exception:
                         pass

           raise ValueError(
               f"Unrecognized processing class in {pretrained_model_name_or_path}. Can't instantiate a processor, a "
               """tokenizer, an image processor or a feature extractor for this model. Make sure the repository contains"""
               """the files of at least one of those processing classes."""   )
    @staticmethod
    def    _SCREAMING_SNAKE_CASE (						snake_case	,snake_case   ):



           '''simple docstring'''







           PROCESSOR_MAPPING.register(snake_case	,snake_case   )
