





'''simple docstring'''

import unittest

from transformers import (
    MODEL_FOR_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
    TextGenerationPipeline,
    logging,
    pipeline,
)
from transformers.testing_utils import (
    CaptureLogger,
    is_pipeline_test,
    require_accelerate,
    require_tf,
    require_torch,
    require_torch_gpu,
    require_torch_or_tf,
)

from .test_pipelines_common import ANY


@is_pipeline_test
@require_torch_or_tf
class    a_	(							unittest.TestCase			):

    '''simple docstring'''
    UpperCamelCase					       =					MODEL_FOR_CAUSAL_LM_MAPPING
    UpperCamelCase					       =					TF_MODEL_FOR_CAUSAL_LM_MAPPING


    @require_torch
    def      snake_case_(						self			)						->  Union[str, Any]:
        _SCREAMING_SNAKE_CASE   							=     pipeline(task="""text-generation"""					,						model="""sshleifer/tiny-ctrl"""					,						framework="""pt"""			)
        # Using `do_sample=False` to force deterministic output
        _SCREAMING_SNAKE_CASE   							=     text_generator("""This is a test"""					,						do_sample=a__			)
        self.assertEqual(
            a__					,						[
                {
                    """generated_text""": (
                        """This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope."""
                        """ oscope. FiliFili@@"""
                    )
                }
            ]					,						)

        _SCREAMING_SNAKE_CASE   							=     text_generator(["""This is a test""", """This is a second test"""]			)
        self.assertEqual(
            a__					,						[
                [
                    {
                        """generated_text""": (
                            """This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope."""
                            """ oscope. FiliFili@@"""
                        )
                    }
                ],
                [
                    {
                        """generated_text""": (
                            """This is a second test ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy"""
                            """ oscope. oscope. FiliFili@@"""
                        )
                    }
                ],
            ]					,						)

        _SCREAMING_SNAKE_CASE   							=     text_generator("""This is a test"""					,						do_sample=a__					,						num_return_sequences=2					,						return_tensors=a__			)
        self.assertEqual(
            a__					,						[
                {"""generated_token_ids""": ANY(a__			)},
                {"""generated_token_ids""": ANY(a__			)},
            ]					,						)
        _SCREAMING_SNAKE_CASE   							=     text_generator.model.config.eos_token_id
        _SCREAMING_SNAKE_CASE   							=     """<pad>"""
        _SCREAMING_SNAKE_CASE   							=     text_generator(
            ["""This is a test""", """This is a second test"""]					,						do_sample=a__					,						num_return_sequences=2					,						batch_size=2					,						return_tensors=a__					,						)
        self.assertEqual(
            a__					,						[
                [
                    {"""generated_token_ids""": ANY(a__			)},
                    {"""generated_token_ids""": ANY(a__			)},
                ],
                [
                    {"""generated_token_ids""": ANY(a__			)},
                    {"""generated_token_ids""": ANY(a__			)},
                ],
            ]					,						)


    @require_tf
    def      snake_case_(						self			)						->  Dict:
        _SCREAMING_SNAKE_CASE   							=     pipeline(task="""text-generation"""					,						model="""sshleifer/tiny-ctrl"""					,						framework="""tf"""			)

        # Using `do_sample=False` to force deterministic output
        _SCREAMING_SNAKE_CASE   							=     text_generator("""This is a test"""					,						do_sample=a__			)
        self.assertEqual(
            a__					,						[
                {
                    """generated_text""": (
                        """This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵"""
                        """ please,"""
                    )
                }
            ]					,						)

        _SCREAMING_SNAKE_CASE   							=     text_generator(["""This is a test""", """This is a second test"""]					,						do_sample=a__			)
        self.assertEqual(
            a__					,						[
                [
                    {
                        """generated_text""": (
                            """This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵"""
                            """ please,"""
                        )
                    }
                ],
                [
                    {
                        """generated_text""": (
                            """This is a second test Chieftain Chieftain prefecture prefecture prefecture Cannes Cannes"""
                            """ Cannes 閲閲Cannes Cannes Cannes 攵 please,"""
                        )
                    }
                ],
            ]					,						)


    def      snake_case_(						self					,						A					,						A					,						A			)						->  str:
        _SCREAMING_SNAKE_CASE   							=     TextGenerationPipeline(model=a__					,						tokenizer=a__			)
        return text_generator, ["This is a test", "Another test"]


    def      snake_case_(						self			)						->  Union[str, Any]:
        _SCREAMING_SNAKE_CASE   							=     """Hello I believe in"""
        _SCREAMING_SNAKE_CASE   							=     pipeline("""text-generation"""					,						model="""hf-internal-testing/tiny-random-gpt2"""			)
        _SCREAMING_SNAKE_CASE   							=     text_generator(a__			)
        self.assertEqual(
            a__					,						[{"""generated_text""": """Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe"""}]					,						)

        _SCREAMING_SNAKE_CASE   							=     text_generator(a__					,						stop_sequence=""" fe"""			)
        self.assertEqual(a__					,						[{"""generated_text""": """Hello I believe in fe"""}]			)


    def      snake_case_(						self					,						A					,						A			)						->  List[Any]:
        _SCREAMING_SNAKE_CASE   							=     text_generator.model
        _SCREAMING_SNAKE_CASE   							=     text_generator.tokenizer

        _SCREAMING_SNAKE_CASE   							=     text_generator("""This is a test"""			)
        self.assertEqual(a__					,						[{"""generated_text""": ANY(a__			)}]			)
        self.assertTrue(outputs[0]["""generated_text"""].startswith("""This is a test"""			)			)

        _SCREAMING_SNAKE_CASE   							=     text_generator("""This is a test"""					,						return_full_text=a__			)
        self.assertEqual(a__					,						[{"""generated_text""": ANY(a__			)}]			)
        self.assertNotIn("""This is a test"""					,						outputs[0]["""generated_text"""]			)

        _SCREAMING_SNAKE_CASE   							=     pipeline(task="""text-generation"""					,						model=a__					,						tokenizer=a__					,						return_full_text=a__			)
        _SCREAMING_SNAKE_CASE   							=     text_generator("""This is a test"""			)
        self.assertEqual(a__					,						[{"""generated_text""": ANY(a__			)}]			)
        self.assertNotIn("""This is a test"""					,						outputs[0]["""generated_text"""]			)

        _SCREAMING_SNAKE_CASE   							=     text_generator("""This is a test"""					,						return_full_text=a__			)
        self.assertEqual(a__					,						[{"""generated_text""": ANY(a__			)}]			)
        self.assertTrue(outputs[0]["""generated_text"""].startswith("""This is a test"""			)			)

        _SCREAMING_SNAKE_CASE   							=     text_generator(["""This is great !""", """Something else"""]					,						num_return_sequences=2					,						do_sample=a__			)
        self.assertEqual(
            a__					,						[
                [{"""generated_text""": ANY(a__			)}, {"""generated_text""": ANY(a__			)}],
                [{"""generated_text""": ANY(a__			)}, {"""generated_text""": ANY(a__			)}],
            ]					,						)

        if text_generator.tokenizer.pad_token is not None:
            _SCREAMING_SNAKE_CASE   							=     text_generator(
                ["""This is great !""", """Something else"""]					,						num_return_sequences=2					,						batch_size=2					,						do_sample=a__			)
            self.assertEqual(
                a__					,						[
                    [{"""generated_text""": ANY(a__			)}, {"""generated_text""": ANY(a__			)}],
                    [{"""generated_text""": ANY(a__			)}, {"""generated_text""": ANY(a__			)}],
                ]					,						)

        with self.assertRaises(a__			):
            _SCREAMING_SNAKE_CASE   							=     text_generator("""test"""					,						return_full_text=a__					,						return_text=a__			)
        with self.assertRaises(a__			):
            _SCREAMING_SNAKE_CASE   							=     text_generator("""test"""					,						return_full_text=a__					,						return_tensors=a__			)
        with self.assertRaises(a__			):
            _SCREAMING_SNAKE_CASE   							=     text_generator("""test"""					,						return_text=a__					,						return_tensors=a__			)

        # Empty prompt is slighly special
        # it requires BOS token to exist.
        # Special case for Pegasus which will always append EOS so will
        # work even without BOS.
        if (
            text_generator.tokenizer.bos_token_id is not None
            or "Pegasus" in tokenizer.__class__.__name__
            or "Git" in model.__class__.__name__
        ):
            _SCREAMING_SNAKE_CASE   							=     text_generator(""""""			)
            self.assertEqual(a__					,						[{"""generated_text""": ANY(a__			)}]			)
        else:
            with self.assertRaises((ValueError, AssertionError)			):
                _SCREAMING_SNAKE_CASE   							=     text_generator(""""""			)

        if text_generator.framework == "tf":
            # TF generation does not support max_new_tokens, and it's impossible
            # to control long generation with only max_length without
            # fancy calculation, dismissing tests for now.
            return
        # We don't care about infinite range models.
        # They already work.
        # Skip this test for XGLM, since it uses sinusoidal positional embeddings which are resized on-the-fly.
        _SCREAMING_SNAKE_CASE   							=     ["""RwkvForCausalLM""", """XGLMForCausalLM""", """GPTNeoXForCausalLM"""]
        if (
            tokenizer.model_max_length < 1_0000
            and text_generator.model.__class__.__name__ not in EXTRA_MODELS_CAN_HANDLE_LONG_INPUTS
        ):
            # Handling of large generations
            with self.assertRaises((RuntimeError, IndexError, ValueError, AssertionError)			):
                text_generator("""This is a test""" * 500					,						max_new_tokens=20			)

            _SCREAMING_SNAKE_CASE   							=     text_generator("""This is a test""" * 500					,						handle_long_generation="""hole"""					,						max_new_tokens=20			)
            # Hole strategy cannot work
            with self.assertRaises(a__			):
                text_generator(
                    """This is a test""" * 500					,						handle_long_generation="""hole"""					,						max_new_tokens=tokenizer.model_max_length + 10					,						)


    @require_torch
    @require_accelerate
    @require_torch_gpu
    def      snake_case_(						self			)						->  Dict:
        import torch

        # Classic `model_kwargs`
        _SCREAMING_SNAKE_CASE   							=     pipeline(
            model="""hf-internal-testing/tiny-random-bloom"""					,						model_kwargs={"""device_map""": """auto""", """torch_dtype""": torch.bfloataa}					,						)
        self.assertEqual(pipe.model.device					,						torch.device(0			)			)
        self.assertEqual(pipe.model.lm_head.weight.dtype					,						torch.bfloataa			)
        _SCREAMING_SNAKE_CASE   							=     pipe("""This is a test"""			)
        self.assertEqual(
            a__					,						[
                {
                    """generated_text""": (
                        """This is a test test test test test test test test test test test test test test test test"""
                        """ test"""
                    )
                }
            ]					,						)

        # Upgraded those two to real pipeline arguments (they just get sent for the model as they're unlikely to mean anything else.)
        _SCREAMING_SNAKE_CASE   							=     pipeline(model="""hf-internal-testing/tiny-random-bloom"""					,						device_map="""auto"""					,						torch_dtype=torch.bfloataa			)
        self.assertEqual(pipe.model.device					,						torch.device(0			)			)
        self.assertEqual(pipe.model.lm_head.weight.dtype					,						torch.bfloataa			)
        _SCREAMING_SNAKE_CASE   							=     pipe("""This is a test"""			)
        self.assertEqual(
            a__					,						[
                {
                    """generated_text""": (
                        """This is a test test test test test test test test test test test test test test test test"""
                        """ test"""
                    )
                }
            ]					,						)

        # torch_dtype will be automatically set to float32 if not provided - check: https://github.com/huggingface/transformers/pull/20602
        _SCREAMING_SNAKE_CASE   							=     pipeline(model="""hf-internal-testing/tiny-random-bloom"""					,						device_map="""auto"""			)
        self.assertEqual(pipe.model.device					,						torch.device(0			)			)
        self.assertEqual(pipe.model.lm_head.weight.dtype					,						torch.floataa			)
        _SCREAMING_SNAKE_CASE   							=     pipe("""This is a test"""			)
        self.assertEqual(
            a__					,						[
                {
                    """generated_text""": (
                        """This is a test test test test test test test test test test test test test test test test"""
                        """ test"""
                    )
                }
            ]					,						)


    @require_torch
    @require_torch_gpu
    def      snake_case_(						self			)						->  List[str]:
        import torch

        _SCREAMING_SNAKE_CASE   							=     pipeline(model="""hf-internal-testing/tiny-random-bloom"""					,						device=0					,						torch_dtype=torch.floataa			)
        pipe("""This is a test"""			)


    @require_torch
    @require_accelerate
    @require_torch_gpu
    def      snake_case_(						self			)						->  Tuple:
        import torch

        _SCREAMING_SNAKE_CASE   							=     pipeline(model="""hf-internal-testing/tiny-random-bloom"""					,						device_map="""auto"""					,						torch_dtype=torch.floataa			)
        pipe("""This is a test"""					,						do_sample=a__					,						top_p=0.5			)





    def      snake_case_(						self			)						->  List[str]:
        _SCREAMING_SNAKE_CASE   							=     """Hello world"""
        _SCREAMING_SNAKE_CASE   							=     pipeline("""text-generation"""					,						model="""hf-internal-testing/tiny-random-gpt2"""			)
        if text_generator.model.framework == "tf":
            _SCREAMING_SNAKE_CASE   							=     logging.get_logger("""transformers.generation.tf_utils"""			)
        else:
            _SCREAMING_SNAKE_CASE   							=     logging.get_logger("""transformers.generation.utils"""			)
        _SCREAMING_SNAKE_CASE   							=     """Both `max_new_tokens`"""  # The beggining of the message to be checked in this test

        # Both are set by the user -> log warning
        with CaptureLogger(a__			) as cl:
            _SCREAMING_SNAKE_CASE   							=     text_generator(a__					,						max_length=10					,						max_new_tokens=1			)
        self.assertIn(a__					,						cl.out			)

        # The user only sets one -> no warning
        with CaptureLogger(a__			) as cl:
            _SCREAMING_SNAKE_CASE   							=     text_generator(a__					,						max_new_tokens=1			)
        self.assertNotIn(a__					,						cl.out			)

        with CaptureLogger(a__			) as cl:
            _SCREAMING_SNAKE_CASE   							=     text_generator(a__					,						max_length=10			)
        self.assertNotIn(a__					,						cl.out			)








from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


_lowercase    	=		logging.get_logger(__name__)

_lowercase    	=		{
    "xlm-roberta-base": "https://huggingface.co/xlm-roberta-base/resolve/main/config.json",
    "xlm-roberta-large": "https://huggingface.co/xlm-roberta-large/resolve/main/config.json",
    "xlm-roberta-large-finetuned-conll02-dutch": (
        "https://huggingface.co/xlm-roberta-large-finetuned-conll02-dutch/resolve/main/config.json"
    ),
    "xlm-roberta-large-finetuned-conll02-spanish": (
        "https://huggingface.co/xlm-roberta-large-finetuned-conll02-spanish/resolve/main/config.json"
    ),
    "xlm-roberta-large-finetuned-conll03-english": (
        "https://huggingface.co/xlm-roberta-large-finetuned-conll03-english/resolve/main/config.json"
    ),
    "xlm-roberta-large-finetuned-conll03-german": (
        "https://huggingface.co/xlm-roberta-large-finetuned-conll03-german/resolve/main/config.json"
    ),
}



class      _UpperCAmelCase      (							A__  ):
     UpperCamelCase__		     =					'''xlm-roberta'''




     def __init__(					self			,    a__=3_0_5_2_2			,    a__=7_6_8			,    a__=1_2			,    a__=1_2			,    a__=3_0_7_2			,    a__="gelu"			,    a__=0.1			,    a__=0.1			,    a__=5_1_2			,    a__=2			,    a__=0.0_2			,    a__=1e-12			,    a__=1			,    a__=0			,    a__=2			,    a__="absolute"			,    a__=True			,    a__=None			,    **a__			,    ):
         super().__init__(pad_token_id=a__			,    bos_token_id=a__			,    eos_token_id=a__			,    **a__)

         A__					=       vocab_size
         A__					=       hidden_size
         A__					=       num_hidden_layers
         A__					=       num_attention_heads
         A__					=       hidden_act
         A__					=       intermediate_size
         A__					=       hidden_dropout_prob
         A__					=       attention_probs_dropout_prob
         A__					=       max_position_embeddings
         A__					=       type_vocab_size
         A__					=       initializer_range
         A__					=       layer_norm_eps
         A__					=       position_embedding_type
         A__					=       use_cache
         A__					=       classifier_dropout







class      _UpperCAmelCase      (							A__  ):




     @property
     def 		snake_case_		(					self):
         if self.task == "multiple-choice":
             A__					=       {0: '''batch''', 1: '''choice''', 2: '''sequence'''}
         else:
             A__					=       {0: '''batch''', 1: '''sequence'''}
         return OrderedDict(
             [
                 ('''input_ids''', dynamic_axis),
                 ('''attention_mask''', dynamic_axis),
             ])
